using DataEntity;
using DataEntity.Share;
using DataRWDAL;
using DriverLib.Engine;
using HandyControl.Controls;
using HxEnum;
using HxSocket;
using MySqlX.XDevAPI.Common;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using System.Xml;
using XCommon;
using XCommon.Log;
using XCore;
using XHandler.Class;
using XHandler.Class.DataEx;
using XHandler.Controls;
using XHandler.Controls.Run;
using XHandler.Controls.Run.Com;
using XHandler.View.Com;
using XHandler.View.MethodProperty;
using XImagingXhandler.XDAL;
using Application = System.Windows.Application;
using Panel = System.Windows.Controls.Panel;
using XImaging.Automation.Service;

namespace XHandler.View
{
    /// <summary>
    /// RunWnd.xaml 的交互逻辑
    /// </summary>
    public partial class RunWnd : System.Windows.Controls.UserControl
    {
        #region 变量
        /// <summary>
        /// 运行日志相关
        /// </summary>
        private static object m_lockTipMsg = new object();
        private ObservableCollection<string> logList = new ObservableCollection<string>();

        private List<LabwareEx> labwareList;
        private List<Lattice> latticeList;
        private MethodEx rootMethod;
        private int nTableRows;
        private int nTableColumns;
        // 实验状态 key:实验ID,value:线程启停控制 
        private static Dictionary<string, ManualResetEvent> dicManualResetEvent = new Dictionary<string, ManualResetEvent>();        // 为true,一开始就可以执行
        private Dictionary<string, int> VariableDictionary = new Dictionary<string, int>();     // 存储方法序列中的所有变量与值

        public event EventHandler closeEvent;
        public CancellationTokenSource _cancelSource = new CancellationTokenSource();       // 取消线程
        public bool EnableSimulator = false;
        public XmlDocument xmlDocument = null;
        public MainWindow mainWindow = null;

        public float currentLengthOfTip = 0f;                               // 当前已加载的Tip去掉插入深度后的Tip长度，用于吸液排液Z轴的计算
        public bool currentIsLoadingTips = false;                           // 当前运行时，设备枪上是否装上了枪头
        public string currentInValidWell = string.Empty;                    // 当前运行时，台面上已经被安装的枪头孔位数据串
        public static List<DropdownName> currentIsUsedWellLattice = new List<DropdownName>();   // 存储当前被使用过的板位和孔配对象，保存在xml文件中
        public string currentWellLatticeId = string.Empty;                  // 当前已安装的枪头所在的板位Id
        public Stack<Variable> gloadVariable = new Stack<Variable>();       // 保存流程中声明的变量
        public DataTable dataTableTotal = new DataTable();                  // 保存所有移液数据记录
        public float fVolumeToNull = 0.0f;                                  // 排到空的体积
        public bool isRemotingOper = false;                                 // 是否是远程整合运行
        public string captureData = string.Empty;                           // 保存当前拍照返回的数据
        //public XmlNode xmlEnvBak = null;                                    // 流程运行前备份env数据

        public List<CoatingLabware> lstCoatingLabware = null;               // 涂布使用的所有目标耗材板
        public string choiceBarcode = string.Empty;                         // 上次往成像位移动的皿的barcode
        public string choiceSrcLabwareSname = string.Empty;                 // 上次往成像位移动的皿的实际板位号
        public int choiceTimes = 1;                                         // 上次往成像节点设置的涂布接种次数
        public string batchId = Guid.NewGuid().ToString();                  // 批次ID（用于暂停）
        public MethodEx selectedMethodEx = null;//当前选中的运行节点--提供给单次运行选中的节点用

        public ExperimentRunLog currentExperimentRunLog = new ExperimentRunLog();//保存当前的运行记录对象
        private double zoomVal = 1.5;       //真实台面与显示台面的比例
        public List<MethodTimer> methodTimers = new List<MethodTimer>();//保存当前正在运行的计时器时间对象
        System.Threading.Timer timeTimer = null;//计时器时间循环计时
        public List<Task> taskForSubmethod = new List<Task>();//保存当前正在运行的异步子流程task对象

        #region 循环命令控制变量
        bool isLoop1Start = false;//是否处在循环之中
        #endregion

        #region 夹爪保持的开始数据对象
        public MethodGripTransport startMethodGripTransport;
        #endregion

        #region BLL
        private MethodListBll methodListBll = new MethodListBll();
        private LabwareBll labwareBll = new LabwareBll();
        private TakePhotoBll takePhotoBll = new TakePhotoBll();
        #endregion

        #region control
        private UnloadTipsControl unloadTipsCtrl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
        #endregion

        #region remote
        public Action<Object, string, int, string, int> OnError;
        public Action<Object, string, int, string, int> OnAbort;
        public Object remoteObjectCmd;//远程专用接收消息参数
        #endregion

        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public RunWnd()
        {
            InitializeComponent();
            mainWindow = (MainWindow)Application.Current.MainWindow;

            // 初始化移液记录表结构
            DataExportBll dataExportBll = new DataExportBll();
            dataTableTotal = dataExportBll.GenerateDataPortStructure().Clone();
            methodTimers = new List<MethodTimer>();
        }
        public RunWnd(List<LabwareEx> labwareList, MethodEx method, bool enableSimulator, XmlDocument xmlDoc)
        {
            if (hadRun)
            {
                return;
            }
            InitializeComponent();

            this.labwareList = labwareList;
            this.rootMethod = method;
            this.EnableSimulator = enableSimulator;
            this.xmlDocument = xmlDoc;
            this.mainWindow = (MainWindow)Application.Current.MainWindow;
            methodTimers = new List<MethodTimer>();

            // 创建台面数据
            CreateLattice(true);
        }
        #endregion

        /// <summary>
        /// 刷新显示界面
        /// </summary>
        /// <param name="labwareList"></param>
        /// <param name="method"></param>
        /// <param name="enableSimulator"></param>
        /// <param name="xmlDoc"></param>
        public void RunWndRefresh(List<LabwareEx> labwareList, MethodEx method, bool enableSimulator, XmlDocument xmlDoc)
        {
            try
            {
                if (runTreeviewWorkflow != null)
                {
                    this.labwareList = labwareList;
                    this.rootMethod = method;
                    this.EnableSimulator = enableSimulator;
                    this.xmlDocument = xmlDoc;

                    // 创建台面数据
                    CreateLattice(false);

                    // 加载台面和流程方法
                    LoadLatticeAndMethod(false);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                if (Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceChoice)
                {
                    double W = gridTable.ActualWidth / Shared.SoftwareInformation.rows;
                    double H = gridTable.ActualHeight / Shared.SoftwareInformation.columns;
                    imgdish.Width = W * 2 - 20;
                    imgdish.Height = H * 2 - 10;
                    imgdish.Visibility = Visibility.Visible;
                    //imgdish1.Visibility = Visibility.Collapsed;
                }
                else if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLiteChoice) ||
                    Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200))
                {
                    //double W = (gridTable.ActualWidth) / Shared.SoftwareInformation.columns;
                    //double H = gridTable.ActualHeight / Shared.SoftwareInformation.rows;
                    //imgdish1.Width = W - 10;
                    //imgdish1.Height = H * 2 - 10;
                    //imgdish1.Visibility = Visibility.Visible;
                    imgdish.Visibility = Visibility.Collapsed;
                }
                else
                {
                    imgdish.Visibility = Visibility.Collapsed;
                    //imgdish1.Visibility = Visibility.Collapsed;
                }

                if (hadRun)
                {
                    return;
                }

                // 加载台面和流程方法
                TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                if (tabletopTemplate == null)
                {
                    LoadLatticeAndMethod(true);
                }

                methodTimers = new List<MethodTimer>();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 创建台面数据
        /// </summary>
        /// <param name="isInitFlg"></param>
        private void CreateLattice(bool isInitFlg = false)
        {
            if (isInitFlg)
            {
                #region 清除缓存
                // 清空所有控件数据
                gridTable.Children.Clear();
                gridTable.RowDefinitions.Clear();
                gridTable.ColumnDefinitions.Clear();
                runTreeviewWorkflow.ItemsSource = null;

                logListbox.ItemsSource = logList;
                if (logList.Count > 0)
                {
                    logList.Clear();
                }
                if (workStack.Count > 0)
                {
                    workStack.Clear();
                }

                // 初始化移液记录表结构
                DataExportBll dataExportBll = new DataExportBll();
                dataTableTotal = dataExportBll.GenerateDataPortStructure().Clone();
                #endregion

                #region 创建台面布局
                //判断当前系统使用的是什么台面模板
                TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                if (tabletopTemplate == null)
                {
                    nTableRows = Shared.SoftwareInformation.rows;
                    nTableColumns = Shared.SoftwareInformation.columns;
                    if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLiteChoice) ||
                        Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200))
                    {
                        // 第6列是垃圾桶
                        nTableColumns++;
                    }

                    // 获取台面点位信息
                    latticeList = DataModule.getInstance().GetLattices();

                    // 流程跟踪
                    runTreeviewWorkflow.ItemsSource = rootMethod.Children;

                    // 台面布局
                    for (int i = 0; i < nTableRows; i++)
                    {
                        gridTable.RowDefinitions.Add(new RowDefinition());
                    }
                    for (int j = 0; j < nTableColumns; j++)
                    {
                        gridTable.ColumnDefinitions.Add(new ColumnDefinition());
                    }

                    int latticeNum = 1;    // PN
                    for (int iColumnIndex = 0; iColumnIndex < nTableColumns; iColumnIndex++)
                    {
                        for (int iRowIndex = 0; iRowIndex < nTableRows; iRowIndex++)
                        {
                            // 板位索引
                            int latticeIndex = iColumnIndex * Shared.SoftwareInformation.rows + iRowIndex;
                            if (latticeIndex + 1 > latticeList.Count)
                            {
                                break;
                            }

                            // 微牧：P16与P17合并单元格，不添加P17控件
                            if ((Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceLiteChoice ||
                                Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200)) &&
                                latticeNum == mainWindow.ChoiceLatticeId + 1)
                            {
                                latticeNum++;
                                continue;
                            }

                            // Lite：P10与P11、P12合并单元格，不添加P11、P12控件
                            if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLite) &&
                                (latticeNum == 11 || latticeNum == 12))
                            {
                                latticeNum++;
                                continue;
                            }

                            // 是否是垃圾桶
                            bool isTrash = latticeList[latticeIndex].is_trash == 1;

                            // 添加台面布置格子
                            Canvas canvas = AddTableItems(iRowIndex, iColumnIndex, latticeNum, isTrash);
                            if (!isInitFlg)
                            {
                                canvas.Width = (gridTable.ActualWidth - 10d * 2 * nTableColumns) / (double)nTableColumns;
                                canvas.Height = (gridTable.ActualHeight - 10d * 2 * nTableRows) / (double)nTableRows;

                                if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLiteChoice) ||
                                    Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200))
                                {
                                    // 成像板位
                                    if (latticeNum == mainWindow.ChoiceLatticeId)
                                    {
                                        canvas.Height = (canvas.Height + 10d) * 2;
                                    }
                                    // 垃圾桶
                                    else if (isTrash)
                                    {
                                        canvas.Height = (canvas.Height + 10d) * 3;
                                    }
                                }
                            }
                            latticeNum++;

                            int ncol = nTableColumns - iColumnIndex - 1;
                            int zindex = ncol * nTableRows + iRowIndex;
                            Panel.SetZIndex(canvas, zindex);
                        }
                    }
                }
                else
                {
                    SetTabletopGraduated();

                    //加载台面板位
                    //加载该台面模板
                    ObservableCollection<Lattice> latticesList = TabletopTemplateDB.GetLatticesByTabletopTemplateId(tabletopTemplate.tabletopid);
                    int iLatticeCount = 0;
                    numOfCanvas = 0;
                    foreach (Lattice lattice in latticesList)
                    {
                        // 是否是垃圾桶
                        bool isTrash = (lattice.is_trash == 1) ? true : false;
                        //if (isTrash)
                            //nTrashIndex = Convert.ToInt32(lattice.lattice_num.Substring(1, lattice.lattice_num.Length - 1));

                        // 添加台面布置格子
                        Canvas canvas = AddLatticeIntoTabletop(lattice, tabletopTemplate.tabletopid);
                        //latticeNum++;

                        //int ncol = nTableColumns - iColumnIndex - 1;
                        int zindex = (latticesList.Count - iLatticeCount++);
                        Panel.SetZIndex(canvas, zindex);

                        if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLiteChoice) ||
                            Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200))
                        {
                            if (Convert.ToInt32(lattice.lattice_num.Substring(1, lattice.lattice_num.Length - 1)) == mainWindow.ChoiceLatticeId - 1)        // P16、P17
                            {
                                Labware lbe = LabwareDB.GetLabware(ConfigurationManager.AppSettings["choicelabwareId"].ToString());
                                ControlLabware control = new ControlLabware();
                                if (lbe.labware_type_id == EnumManagement.GetEnumValue(ConsumableTypeEnum.CircularDish).ToString())     // 圆形皿
                                {
                                    control.LabwareWidth = canvas.ActualWidth;
                                    control.LabwareHeight = canvas.ActualHeight;
                                    control.LeftSideColor = ComUtility.RGBToColor(lbe.labware_color_lside);
                                    control.FrontColor = ComUtility.RGBToColor(lbe.labware_color_front);
                                    control.TopColor = ComUtility.RGBToColor(lbe.labware_color_top);
                                    control.BorderColor = ComUtility.RGBToColor(lbe.labware_color_line);
                                    control.Rows = (int)lbe.number_row;
                                    control.Columns = (int)lbe.number_column;
                                    control.WellColor = Colors.White;
                                    control.IsFill = true;
                                    control.Label = canvas.Name;
                                    control.LabwareType = Convert.ToInt16(lbe.labware_type_id);
                                    control.ValidWells = "";

                                    control.Width = canvas.ActualWidth;
                                    control.Height = canvas.ActualHeight + 4;
                                }

                                Canvas.SetLeft(control, 0);
                                Canvas.SetBottom(control, 0);

                                LabwareEx lb = new LabwareEx(lbe);

                                lb.row = Grid.GetRow(canvas);
                                lb.col = Grid.GetColumn(canvas);
                                lb.position = canvas.Name;
                                lb.validWells = control.ValidWells;

                                canvas.DataContext = lb;
                                canvas.Children.Add(control);
                                control.SetValidWells(control.ValidWells);
                            }
                        }
                        /*else if (Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceHXELEC)//电泳切胶槽位置
                        {
                            if (Convert.ToInt32(lattice.lattice_num.Substring(1, lattice.lattice_num.Length - 1)) == 1)        // P1
                            {
                                Labware lbe = LabwareDB.GetLabware(ConfigurationManager.AppSettings["choicelabwareId"].ToString());
                                ControlLabware control = new ControlLabware();
                                if (lbe.labware_type_id == EnumManagement.GetEnumValue(ConsumableTypeEnum.Electrophoto).ToString())     //电泳槽
                                {
                                    control.LabwareWidth = canvas.Width;
                                    control.LabwareHeight = canvas.Height;
                                    control.LabwareRealLength = lbe.labware_length;
                                    control.LabwareRealWidth = lbe.labware_width;
                                    control.Rows = (int)lbe.number_row;
                                    control.Columns = (int)lbe.number_column;
                                    control.WellColor = Colors.White;
                                    control.IsFill = true;
                                    control.Label = canvas.Name;
                                    control.LabwareName = lbe.labware_name;
                                    control.LabwareType = Convert.ToInt16(lbe.labware_type_id);
                                    control.ValidWells = "";
                                    control.labwareWellInfoList = lbe.labwareWellInfoList;

                                    control.Width = canvas.Width;
                                    control.Height = canvas.Height + 4;
                                    control.Loaded += ControlLabware_Loaded;
                                }

                                Canvas.SetLeft(control, 0);
                                if (lbe.labware_type_id == EnumManagement.GetEnumValue(ConsumableTypeEnum.Electrophoto).ToString())     //电泳切胶槽
                                {
                                    Canvas.SetTop(control, 0);
                                }
                                else
                                {
                                    Canvas.SetBottom(control, 0);
                                }

                                LabwareEx lb = new LabwareEx(lbe);

                                lb.row = Grid.GetRow(canvas);
                                lb.col = Grid.GetColumn(canvas);
                                lb.position = canvas.Name;
                                lb.validWells = control.ValidWells;

                                canvas.DataContext = lb;
                                canvas.Children.Add(control);
                                control.SetValidWells(control.ValidWells);
                            }
                        }*/
                    }

                    // 流程跟踪
                    runTreeviewWorkflow.ItemsSource = rootMethod.Children;
                }
                #endregion
            }
            else
            {
                runTreeviewWorkflow.ItemsSource = null;

                logListbox.ItemsSource = logList;
                if (logList.Count > 0)
                {
                    logList.Clear();
                }
                if (workStack.Count > 0)
                {
                    workStack.Clear();
                }
                // 流程跟踪
                runTreeviewWorkflow.ItemsSource = rootMethod.Children;

                ClearLattices();
            }

            // 模拟运行/真机运行
            tbxRunTitle.Text = EnableSimulator ? Properties.Resources.strSimulatorRun : Properties.Resources.strRealMachineRun;
        }

        #region 布局当前台面的大小
        /// <summary>
        /// 布局当前台面的大小
        /// </summary>
        public void SetTabletopGraduated()
        {
            double length = Shared.SoftwareInformation.realtabletoplength;//mm
            double width = Shared.SoftwareInformation.realtabletopwidth;//mm

            gridTable.Width = length / zoomVal;//统一缩小，即1个像素代表2.5mm
            gridTable.Height = width / zoomVal;
        }
        #endregion

        #region 向新布局的台面中添加板位--板位用canvas
        public Canvas AddLatticeIntoTabletop(Lattice lattice, string tabletopid)
        {
            int latticeId = Convert.ToInt32(lattice.lattice_num.Substring(1, lattice.lattice_num.Length - 1));
            bool bAllowDrop = true;
            if (latticeId == mainWindow.ChoiceLatticeId)
            {
                bAllowDrop = false;
            }
            else if ((Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLiteChoice) ||
                Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200)) &&
                latticeId == 19)
            {
                latticeId = 0;
            }

            TabletopRelLattice tabletopRelLattice = TabletopRelLatticeDB.GetTabletopRelLatticeByTabletopIdAndLatticeId(tabletopid, Convert.ToInt32(lattice.lattice_id));

            Canvas canvas = new Canvas()
            {
                Margin = new Thickness(6, 6, 6, 6),
                AllowDrop = bAllowDrop,
                Name = "P" + latticeId.ToString(),
                Width = LabwareDB.GetLabware(tabletopRelLattice.labware_id).labware_length / zoomVal,
                Height = LabwareDB.GetLabware(tabletopRelLattice.labware_id).labware_width / zoomVal
            };

            TextBlock tb = new TextBlock();
            tb.Text = "P" + latticeId.ToString();
            tb.FontSize = 18;
            tb.Foreground = Brushes.Black;
            tb.VerticalAlignment = VerticalAlignment.Center;
            tb.HorizontalAlignment = HorizontalAlignment.Center;

            Border border = new Border()
            {
                Background = Brushes.DarkGray,
                CornerRadius = new CornerRadius(5),
                Child = tb,
            };
            canvas.Children.Add(border);

            canvas.SizeChanged += Canvas_SizeChanged;

            canvas.Loaded += Canvas_Loaded;


            canvas.Tag = tabletopRelLattice;

            if (lattice.is_trash == 1)
            {
                ControlLabware cl = new ControlLabware()
                {
                    IsTrash = true,
                    LabwareName = Properties.Resources.strTrash.ToString()
                };
                LabwareEx lb = new LabwareEx();
                lb.labware_name = Properties.Resources.strTrash;

                //lb.row = row;
                //lb.col = column;
                canvas.DataContext = lb;
                canvas.Children.Add(cl);
            }

            gridTable.Children.Add(canvas);
            //Grid.SetColumn(canvas, column);
            //Grid.SetRow(canvas, row);

            if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLiteChoice) ||
                Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200))
            {
                #region 挑菌台面暂时屏蔽
                /*if (lattice.is_trash == 1)
                {
                    Grid.SetColumnSpan(canvas, 1);
                    Grid.SetRowSpan(canvas, 3);
                }
                else if (latticeId == mainWindow.ChoiceLatticeId)
                {
                    Grid.SetColumnSpan(canvas, 1);
                    Grid.SetRowSpan(canvas, 2);

                    // 将Image控件添加到Canvas上
                    Image image = new Image();
                    image.Source = (ImageSource)(new ImageSourceConverter()).ConvertFrom(new Uri(@"pack://application:,,,/XHandler;component/Assets/dish_LiteChoice.png"));
                    image.Stretch = Stretch.Fill;
                    image.Width = canvas.Width - 4;
                    image.Height = canvas.Height - 23;

                    Canvas.SetLeft(image, 2);
                    Canvas.SetTop(image, 2);
                    canvas.Children.Add(image);

                    Panel.SetZIndex(image, 99);
                }*/
                #endregion
            }

            return canvas;
        }
        #endregion

        #region 板位加载显示完成后，处理布局
        int numOfCanvas = 0;//记录已加载的板位数
        private void Canvas_Loaded(object sender, RoutedEventArgs e)
        {
            Canvas canvasOfLattice = sender as Canvas;
            canvasOfLattice.HorizontalAlignment = HorizontalAlignment.Left;
            canvasOfLattice.VerticalAlignment = VerticalAlignment.Top;
            canvasOfLattice.Loaded -= Canvas_Loaded;//运行完去掉

            //换算在新的平面坐标中，板位的位置
            if (canvasOfLattice.Tag == null)
            {
                return;
            }
            TabletopRelLattice tabletopRelLattice = (TabletopRelLattice)canvasOfLattice.Tag;
            double xPixelVal = tabletopRelLattice.lattice_pixel_x / (zoomVal / (double)2);
            double yPixelVal = tabletopRelLattice.lattice_pixel_y / (zoomVal / (double)2);
            canvasOfLattice.Margin = new Thickness(xPixelVal, yPixelVal, 0, 0);
            canvasOfLattice.Tag = null;
            

            numOfCanvas++;

            ObservableCollection<Lattice> latticesList = TabletopTemplateDB.GetLatticesByTabletopTemplateId(tabletopRelLattice.tabletopid);
            if (numOfCanvas == latticesList.Count)
            {
                //加载耗材
                LoadLatticeAndMethod(true);
                numOfCanvas = 0;
            }
        }
        #endregion

        #region 清空台面耗材
        public void ClearLattices()
        {
            foreach (Canvas canvas in gridTable.Children)
            {
                if (canvas.DataContext != null)
                {
                    LabwareEx labware = canvas.DataContext as LabwareEx;
                    if (!string.IsNullOrEmpty(labware.labware_id))
                    {
                        canvas.DataContext = null;
                        canvas.Tag = null;
                        for (int i=canvas.Children.Count-1;i>0;i--)
                        {
                            var item = canvas.Children[i];
                            canvas.Children.Remove(item);
                        }
                    }
                }
            }
        }
        #endregion

        /// <summary>
        /// 加载台面和流程方法
        /// </summary>
        /// <param name="isInitFlg"></param>
        private void LoadLatticeAndMethod(bool isInitFlg = false)
        {
            #region 加载流程和台面
            foreach (var lb in labwareList)
            {
                int row = lb.row;
                int col = lb.col;

                // 获取台面对应格子的Canvas
                Canvas canvas = null;
                TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                if (tabletopTemplate == null)
                {
                    canvas = GetGridTableCanvas(row, col);
                }
                else
                {
                    canvas = GetCanvasByLatticeNumOfLabware(lb);
                }

                Stack<LabwareEx> labwareExes = new Stack<LabwareEx>();
                if (canvas == null)
                {
                    continue;
                }

                ControlLabware control;
                if (string.IsNullOrEmpty(lb.labware_id))
                {
                    control = new ControlLabware()
                    {
                        IsTrash = true,
                        Width = canvas.ActualWidth,
                        Height = canvas.ActualHeight,
                    };
                }
                else
                {
                    control = new ControlLabware();
                    control.AllowDrop = true;
                    double canvasWidth = 0d;
                    double canvasHeight = 0d;
                    if (isInitFlg)
                    {
                        canvasWidth = canvas.ActualWidth;
                        canvasHeight = canvas.ActualHeight;
                    }
                    else
                    {
                        canvasWidth = canvas.ActualWidth == 0 ? canvas.Width : canvas.ActualWidth;
                        canvasHeight = canvas.ActualHeight == 0 ? canvas.Height : canvas.ActualHeight;
                    }

                    if (canvas.Name.Equals(ConfigurationManager.AppSettings["choiceLatticeId"].ToString()))
                    {
                        control.LabwareWidth = canvasWidth - 5;
                        control.LabwareHeight = canvasHeight / 2;
                    }
                    else
                    {
                        control.LabwareWidth = canvasWidth;
                        control.LabwareHeight = canvasHeight;
                    }

                    control.LeftSideColor = ComUtility.RGBToColor(lb.labware_color_lside);
                    control.FrontColor = ComUtility.RGBToColor(lb.labware_color_front);
                    control.TopColor = ComUtility.RGBToColor(lb.labware_color_top);
                    control.BorderColor = ComUtility.RGBToColor(lb.labware_color_line);

                    control.Rows = (int)lb.number_row;
                    control.Columns = (int)lb.number_column;
                    control.WellColor = Colors.White;
                    control.IsFill = true;
                    control.Label = (string.IsNullOrEmpty(lb.labware_sname) ? lb.position : lb.labware_sname);
                    control.LabwareName = lb.labware_name;
                    control.LabwareType = Convert.ToInt16(lb.labware_type_id);
                    control.ValidWells = lb.validWells;
                    //control.InValidWells = lb.invalidWells;
                    if (lb.labware_type_id == EnumManagement.GetEnumValue(ConsumableTypeEnum.Tube).ToString())     //管架
                    {
                        control.LabwareRealLength = lb.labware_length;
                        control.LabwareRealWidth = lb.labware_width;
                        control.labwareWellInfoList = lb.labwareWellInfoList;
                    }
                    if (lb.labware_type_id == EnumManagement.GetEnumValue(ConsumableTypeEnum.Electrophoto).ToString())     //电泳切胶槽
                    {
                        control.LabwareRealLength = lb.labware_length;
                        control.LabwareRealWidth = lb.labware_width;
                        control.labwareWellInfoList = lb.labwareWellInfoList;
                        control.Loaded += ControlLabware_Loaded;
                    }
                }
                Canvas.SetLeft(control, 0);
                if (lb.labware_type_id == EnumManagement.GetEnumValue(ConsumableTypeEnum.Electrophoto).ToString())     //电泳切胶槽
                {
                    Canvas.SetTop(control, 0);
                }
                else
                {
                    Canvas.SetBottom(control, 0);
                }
                lb.label = lb.position;
                canvas.DataContext = lb;
                labwareExes = (Stack<LabwareEx>)canvas.Tag;
                if (labwareExes != null)
                {
                }
                else
                {
                    labwareExes = new Stack<LabwareEx>();
                }
                labwareExes.Push(lb);
                canvas.Tag = labwareExes;
                //根据重叠的层级，设置margin，用的是下层的耗材数据计算
                double leftMargin = 0;//离左侧距离
                double bottomMargin = 0;//离底部距离
                for (int i = 0; i < canvas.Children.Count; i++)
                {
                    ControlLabware a = canvas.Children[i] as ControlLabware;
                    if (a != null)
                    {
                        leftMargin += a.LabwareDeep;
                        bottomMargin += a.LabwareDeep;
                    }
                }

                control.Margin = new Thickness(leftMargin, 0, 0, bottomMargin);
                canvas.Children.Add(control);

                Border labelText = Utilities.FindVisualChild<Border>(canvas);
                if (labelText != null)
                {
                    labelText.Width = canvas.ActualWidth;
                }

                //如果是第二及其以上耗材，要隐藏标签
                if (labwareExes.Count > 1)
                {
                    control.Label = "";
                }
                else
                {
                    control.Label = (string.IsNullOrEmpty(lb.labware_sname) ? lb.position : lb.labware_sname);
                }
            }

            if (runTreeviewWorkflow.Items.Count > 0)
            {
                TreeViewItem tvi = runTreeviewWorkflow.ItemContainerGenerator.ContainerFromItem(runTreeviewWorkflow.Items[0]) as TreeViewItem;
                if (tvi != null)
                {
                    tvi.Focus();
                }
            }
            #endregion
        }

        #region 耗材加载后，重新设置高度
        private void ControlLabware_Loaded(object sender, RoutedEventArgs e)
        {
            var controlLabware = sender as ControlLabware;
            if (controlLabware != null)
            {
                controlLabware.Height = ((Canvas)(controlLabware.Parent)).Height;
                controlLabware.Width = ((Canvas)(controlLabware.Parent)).Width;
            }
        }
        #endregion

        #region 根据当前耗材所在的板位名称查找板位对象
        /// <summary>
        /// 根据当前耗材所在的板位名称查找板位对象
        /// </summary>
        /// <param name="labwareEx">当前耗材对象</param>
        /// <returns>符合条件的板位对象</returns>
        public Canvas GetCanvasByLatticeNumOfLabware(LabwareEx labwareEx)
        {
            List<Canvas> canvasList = Utilities.FindAllVisualChild<Canvas>(gridTable);
            foreach(Canvas canvas in canvasList)
            {
                if(canvas.Name==labwareEx.position)
                {
                    return canvas;
                }
            }

            return null;
        }
        #endregion

        #region 设计界面板位名称查找板位对象
        /// <summary>
        /// 
        /// </summary>
        /// <param name="labwareEx"></param>
        /// <returns></returns>
        public Canvas GetCanvasByLatticeNumOfLabwareMainForm(LabwareEx labwareEx)
        {
            if (mainWindow != null)
            {
                foreach (var canvasItem in mainWindow.testDesign.gridTable.Children)
                {
                    Canvas canvas = canvasItem as Canvas;
                    if (canvas.Name == labwareEx.position)
                    {
                        return canvas;
                    }
                }
            }
            return null;
        }
        #endregion

        #region 加载当前运行方法的labware到台面
        public int LoadLabwareOnRunningRemote()
        {
            int iresult = 1;
            try
            {
                //2.找到台面运行的开始节点
                XmlNode startNode = xmlDocument.SelectSingleNode("root/method[isrun='运行起点']");
                if (startNode != null)
                {
                    int mid = Convert.ToInt32(startNode.Attributes["id"].Value);

                    if (startNode.SelectSingleNode("name").InnerText == "start")
                    {
                        mid = mid;
                    }
                    //Task<int> taskMain= Task.Run(() =>
                    //{
                    iresult = ExecMethodList(xmlDocument, mid);
                    //return iresult;
                    //},_cancelSource.Token);


                    //iresult = taskMain.Result;
                }
                if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                {
                    LoggerHelper.InfoLog("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>" + Properties.MachineRunResource.strSystem.ToString() + Properties.MachineRunResource.strGameOver.ToString());
                    LoggerHelper.InfoLog("///////////////////////////////////////////////////////////////////////////////////////////////////////////////////");
                }
                else
                {
                    LoggerHelper.InfoLog("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>System:End method-complete.");
                    LoggerHelper.InfoLog("///////////////////////////////////////////////////////////////////////////////////////////////////////////////////");
                }
                MethodAction.Instance.OnAlarm -= GenerateAlarmingMessage;
            }
            catch(Exception ex)
            {
                LoggerHelper.InfoLog("执行错误：" + ex.Message.ToString());
            }
            return iresult;
        }
        #endregion

        #region 告警事件处理
        private void GenerateAlarmingMessage(object sender, EventArgs e)
        {
            if (Shared.SoftwareInformation.currentculture.Equals("zh_CN"))
            {
                AddLogs("运行出现异常报警，消息源:" + sender.ToString() + ";事件:" + e.ToString());
                LoggerRunHelper.WarnLog("运行出现异常报警，消息源:" + sender.ToString() + ";事件:" + e.ToString());
                if (isRemotingOper)
                {
                    OnError?.Invoke(remoteObjectCmd, "EC-1041", 5, "程序运行中遇到错误（具体原因请查看日志），运行方法终止.", 2);
                }
            }
            else
            {
                AddLogs("There is a alarm on the running task, source:" + sender.ToString() + ";event:" + e.ToString());
                LoggerRunHelper.WarnLog("There is a alarm on the running task, source:" + sender.ToString() + ";event:" + e.ToString());
                if (isRemotingOper)
                {
                    OnError?.Invoke(remoteObjectCmd, "EC-1041", 5, "程序运行中遇到错误（具体原因请查看日志），运行方法终止.", 2);
                }
            }
        }
        #endregion

        #region 加载当前运行方法的labware到台面
        public async Task<int> LoadLabwareOnRunning()
        {
            int iresult = 1;
            //XmlDocument xmlDocument = new XmlDocument();
            System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
            {
                //Window wnd = Application.Current.MainWindow;
                //xmlDocument = wnd.testDesign.GenerateLaunchXmlDocument();
            }));

            #region 登录实验表、实验运行表
            Shared.Exp = AddExp(xmlDocument.OuterXml);
            LoggerRunHelper.InfoLog(string.Format("【{0}】>experimentid = {1}, 实验开始 ====================== ",
                Properties.MachineRunResource.strSystem, Shared.Exp.ExperimentId));
            #endregion

            #region 运行开始节点
            XmlNode startNode = xmlDocument.SelectSingleNode("root/method[isrun='运行起点']");
            if (startNode != null)
            {
                int mid = Convert.ToInt32(startNode.Attributes["id"].Value);
                // 流程运行前备份env数据
                //xmlEnvBak = xmlDocument.SelectSingleNode("root/env").Clone();

                if (startNode.SelectSingleNode("name").InnerText == "start")
                {
                    mid = mid;
                }
                await Task.Run(() =>
                {
                    iresult = ExecMethodList(xmlDocument, mid);
                    Task.WaitAll(taskForSubmethod.ToArray());
                }, _cancelSource.Token);
            }
            #endregion

            #region 更新运行状态、结束时间
            Shared.Exp.EndTime = DateTime.Now;
            // 0：失败；2：停止
            if (iresult == 0 || iresult == 2)
            {
                Shared.Exp.Status = EnumManagement.GetEnumValue(ExpStatusEnum.Stop);        // 异常终止
            }
            else
            {
                Shared.Exp.Status = EnumManagement.GetEnumValue(ExpStatusEnum.Completed);   // 1;正常结束
            }
            ExperimentDB.Update(Shared.Exp);
            #endregion

            #region 结束日志
            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
            {
                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>" + Properties.MachineRunResource.strSystem.ToString() + Properties.MachineRunResource.strGameOver.ToString());
            }
            else
            {
                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>System:End method-complete.");
            }

            LoggerRunHelper.InfoLog(string.Format("【{0}】>experimentid = {1}, 实验结束 ====================== ",
                Properties.MachineRunResource.strSystem, Shared.Exp.ExperimentId));
            #endregion

            #region 状态7 运行结束 蓝闪/蜂鸣5S
            HxResult ret = CommonBll.StatusLamp(7, EnableSimulator);
            if (!isRemotingOper)
            {
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    string strMsg = string.Empty;
                    if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                    {
                        strMsg = iresult == 1 ? Properties.MachineRunResource.strMethodRunSuccess.ToString() : Properties.MachineRunResource.strMethodRunFail.ToString();
                    }
                    else
                    {
                        strMsg = iresult == 1 ? "method-complete!" : "method-fail!";
                    }
                    PlsToolTipWin plsToolTipWin = new PlsToolTipWin(strMsg);
                    plsToolTipWin.Height = this.ActualHeight;
                    plsToolTipWin.Width = this.ActualWidth;

                    SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(0, 0, 0, 0));
                    plsToolTipWin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                    plsToolTipWin.btnCancel.Visibility = Visibility.Hidden;
                    plsToolTipWin.ShowDialog();
                }));
            }
            #endregion

            return iresult;
        }
        #endregion

        /// <summary>
        /// 执行流程中方法
        /// </summary>
        /// <param name="xmlDocument"></param>
        /// <param name="startId"></param>
        /// <returns>0：失败；1：成功；2：停止；3：skip</returns>
        public int ExecMethodList(XmlDocument xmlDocument, int startId)
        {
            int resultExc = 1;
            // 方法
            XmlNodeList xmlNodeMethodList = xmlDocument.SelectNodes("root/method[@id>=" + startId + "]");
            XmlNode xmlEnv = xmlDocument.SelectSingleNode("root/env");
            var platformNodeList = xmlEnv.SelectNodes("platform");
            bool bResult = false;
            int ind = 0;

            //生成运行时台面所有板位上的对象数据

            // 清空方法列表
            for (int n = 0; n < xmlNodeMethodList.Count; n++)
            {
                string MethodName = xmlNodeMethodList[n].SelectSingleNode("label").InnerText;
                workStack.Push(MethodName);
                string id = xmlNodeMethodList[n].Attributes["id"].Value.ToString();
                string strIndex = xmlNodeMethodList[n].SelectSingleNode("strIndex").InnerText;
                float xAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["xAxisSafeVal"]);
                float yAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["yAxisSafeVal"]);
                float zAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["zAxisSafeVal"]);

                int iNum = methodListBll.getNumByMethodName(MethodName);
                if (_cancelSource.IsCancellationRequested)
                {
                    _cancelSource = new CancellationTokenSource();
                    return 2;
                }

                if (xmlNodeMethodList[n].SelectSingleNode("status")==null)
                {
                    continue;
                }

                if(xmlNodeMethodList[n].SelectSingleNode("status").InnerText != "enable")
                {
                    continue;
                }

                if(selectedMethodEx == null)
                {

                }
                else if(ExistNodeByNodeIndex(selectedMethodEx, strIndex))
                {

                }
                else if(!ExistNodeByNodeIndex(selectedMethodEx,strIndex))
                {
                    continue;
                }

                // 设置节点状态
                SetRunningStatus(strIndex);

                switch (iNum)
                {
                    case (int)MethodNameEnum.start:             // 开始
                        #region 开始
                        lstCoatingLabware = null;      // 清空涂布使用的所有目标耗材板

                        string usehepa = xmlNodeMethodList[n].SelectSingleNode("usehepa").InnerText;
                        string isReset = xmlNodeMethodList[n].SelectSingleNode("isreset").InnerText;
                        string isCheckTakePhotoPlate = xmlNodeMethodList[n].SelectSingleNode("isCheckTakePhotoPlate").InnerText;

                        #region 复位
                        bool isOk = DoRest(this, isReset, xmlNodeMethodList[n]);
                        if (!isOk)
                        {
                            return 2;
                        }
                        #endregion

                        #region 检查成像板位是否有板
                        if (ConfigurationManager.AppSettings["openTakePhoto"].ToString() == "true")
                        {
                            isOk = DoCheckTakePhotoPlate(isCheckTakePhotoPlate, EnableSimulator);
                            if (!isOk)
                            {
                                return 2;
                            }
                        }
                        #endregion
                        #endregion
                        break;

                    case (int)MethodNameEnum.aspirate:          // 吸液
                        #region 吸液
                        AspirateControl aspirateControl = new AspirateControl(Shared.SoftwareInformation.currentculture);
                        aspirateControl.launchView = this;
                        bResult = aspirateControl.ExecuteAspirate(xmlEnv, xmlNodeMethodList[n], currentLengthOfTip, zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;

                    case (int)MethodNameEnum.dispense:          // 排液
                        #region 排液
                        DispenseControl dispenseControl = new DispenseControl(Shared.SoftwareInformation.currentculture);
                        dispenseControl.launchView = this;
                        // 是否在循环中，当前循环的
                        bResult = dispenseControl.ExecuteDispense(xmlEnv, xmlNodeMethodList[n], currentLengthOfTip, zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;

                    case (int)MethodNameEnum.end:               // 结束
                        #region 结束
                        lstCoatingLabware = null;      // 清空涂布使用的所有目标耗材板
                        ChoiceTransferControl.ChoiceData = null;
                        CoatingTransferControl.CoatingData = null;

                        string isGoHome = xmlNodeMethodList[n].SelectSingleNode("isGoHome").InnerText;
                        string isTipsOff = xmlNodeMethodList[n].SelectSingleNode("isTipsOff").InnerText;
                        if (!isRemotingOper)
                        {
                            if (mainWindow.wasLoadedTip)//抢上有枪头，需要卸载
                            {
                                if (isTipsOff.ToLower() == "true")
                                {
                                    //调用执行方法,更新执行结果字符串
                                    UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                                    unloadTipsControl.launchView = this;
                                    unloadTipsControl.ExecuteUnloadTipsInToTrash(platformNodeList, xmlNodeMethodList[n], EnableSimulator);
                                }
                            }
                        }

                        if (isGoHome.ToLower() == "true")
                        {
                            //调用复位
                            //判断是否有未卸载的枪头
                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strStartReset));
                            }
                            else
                            {
                                AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), "start reset"));
                            }

                            //判断是否有未卸载的枪头                           
                            //判断是否有抓取中的板子
                            if (!isRemotingOper)
                            {
                                if (mainWindow.wasLoadedTip)//抢上有枪头，需要卸载
                                {
                                    if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                                    {
                                        AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.RunUnloadTipsResource.strUnloadTip));
                                    }
                                    else
                                    {
                                        AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), "unload tip"));
                                    }
                                }
                            }

                            ////调用复位方法全部轴复位回零
                            //if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            //{
                            //    AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strGoHome));
                            //}
                            //else
                            //{
                            //    AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), "go home"));
                            //}

                            //调用执行方法,更新执行结果字符串
                            HomeControl homeControl = new HomeControl(Shared.SoftwareInformation.currentculture);
                            homeControl.launchView = this;

                            bResult = homeControl.ExecuteHome(xmlNodeMethodList[n], xAxisSafeVal, yAxisSafeVal, zAxisSafeVal, EnableSimulator);
                            if (!bResult) { return 0; }
                        }

                        // 状态3 待机 蓝色
                        CommonBll.StatusLamp(3, EnableSimulator);
                        #endregion
                        break;

                    case (int)MethodNameEnum.endgroup:          // 结束组合
                        #region 结束组合
                        ind = Convert.ToInt32(xmlNodeMethodList[n].Attributes["id"].Value.ToString());
                        return ind;
                    #endregion

                    case (int)MethodNameEnum.endloop:           // 结束循环
                        #region 结束循环
                        {
                            if (isLoop1Start == false)//&& isLoop2Start == false)
                            {
                            }
                            else if (isLoop1Start == true)// && isLoop2Start == false)
                            {
                                //n = n + calculationTotalOfCmdInLoop() + 1;//最外一层循环
                                //isLoop1Start = false;
                                return 1;
                            }
                            else if (isLoop1Start == true)// && isLoop2Start == true)
                            {
                                //isLoop2Start = false;
                                return 1;
                            }
                            else if (isLoop1Start == false)// && isLoop2Start == true)
                            {
                                //isLoop1Start = false;
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.griptransport:     // 抓板转移
                        #region 抓板转移
                        {
                            GripTransportControl gripTransportControl = new GripTransportControl(Shared.SoftwareInformation.currentculture);
                            gripTransportControl.launchView = this;
                            if (isRemotingOper)
                            {
                                gripTransportControl.socketTcpListener = ((MainWindow)Application.Current.MainWindow).socketTcpListener;
                            }
                            else
                            {
                                gripTransportControl.socketTcpListener = mainWindow.socketTcpListener;
                            }
                            bool result = gripTransportControl.ExecuteGripTransport(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.holdingLabware:     // 夹爪保持开始
                        #region 夹爪保持开始
                        {
                            HoldingLabwareControl holdingLabwareControl = new HoldingLabwareControl(Shared.SoftwareInformation.currentculture);
                            holdingLabwareControl.LaunchView = this;
                            if (isRemotingOper)
                            {
                                holdingLabwareControl.SocketTcpListener = ((MainWindow)Application.Current.MainWindow).socketTcpListener;
                            }
                            else
                            {
                                holdingLabwareControl.SocketTcpListener = mainWindow.socketTcpListener;
                            }
                            bool result = holdingLabwareControl.ExecuteBeginHolding(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.endHoldingLabware:     // 夹爪保持结束
                        #region 夹爪保持结束
                        {
                            HoldingLabwareControl holdingLabwareControl = new HoldingLabwareControl(Shared.SoftwareInformation.currentculture);
                            holdingLabwareControl.LaunchView = this;
                            if (isRemotingOper)
                            {
                                holdingLabwareControl.SocketTcpListener = ((MainWindow)Application.Current.MainWindow).socketTcpListener;
                            }
                            else
                            {
                                holdingLabwareControl.SocketTcpListener = mainWindow.socketTcpListener;
                            }
                            bool result = holdingLabwareControl.ExecuteEndHolding(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.group:             // 组合
                        #region 组合
                        {
                            int loopStartId = Convert.ToInt32(xmlNodeMethodList[n].Attributes["id"].InnerText);
                            ind = ExecMethodList(xmlDocument, loopStartId + 1);
                            if (ind == 0 || ind == 2)       // 失败、停止
                            {
                                return ind;
                            }
                            else if (ind == 3)              // skip
                            {
                            }

                            //记住当前n的值
                            n = n + ind - loopStartId;
                            //n = n + calculationTotalOfCmdInGroup() + 1;//最外一层组合
                        }
                        #endregion

                        break;
                    case (int)MethodNameEnum.home:              // 复位
                        #region 复位
                        {
                            //调用复位
                            //判断是否有未卸载的枪头
                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strStartReset));
                            }
                            else
                            {
                                AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), "start reset"));
                            }

                            //判断是否有未卸载的枪头                           
                            //判断是否有抓取中的板子
                            if (!isRemotingOper)
                            {
                                if (mainWindow.wasLoadedTip)//抢上有枪头，需要卸载
                                {
                                    if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                                    {
                                        AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.RunUnloadTipsResource.strUnloadTip));
                                    }
                                    else
                                    {
                                        AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), "unload tip"));
                                    }
                                }
                            }

                            //调用复位方法全部轴复位回零
                            //if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            //{
                            //    AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strGoHome));
                            //}
                            //else
                            //{
                            //    AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), "go home"));
                            //}

                            //调用执行方法,更新执行结果字符串
                            HomeControl homeControl = new HomeControl(Shared.SoftwareInformation.currentculture);
                            homeControl.launchView = this;

                            bResult = homeControl.ExecuteHome(xmlNodeMethodList[n], xAxisSafeVal, yAxisSafeVal, zAxisSafeVal, EnableSimulator);
                            if (!bResult) { return 0; }
                            CommonBll.StatusLamp(4, EnableSimulator);
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.loadtips:          // 安装吸头
                        #region 安装吸头
                        {
                            if (_cancelSource.IsCancellationRequested)
                            {
                                return 2;
                            }

                            //调用执行方法,更新执行结果字符串
                            LoadTipsControl loadTipsControl = new LoadTipsControl(Shared.SoftwareInformation.currentculture);
                            if (!isRemotingOper)
                            {
                                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                                {
                                    LoadTipsControl.launchView = this;

                                    if (mainWindow.wasLoadedTip)
                                    {
                                        MessageBoxResult msbox = System.Windows.MessageBox.Show("可能有枪头未卸载，是否先卸载？", "提示", MessageBoxButton.YesNo);
                                        if (msbox == MessageBoxResult.Yes)
                                        {
                                            //调用执行方法,更新执行结果字符串
                                            UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                                            unloadTipsControl.launchView = this;
                                            unloadTipsControl.ExecuteUnloadTipsInToTrash(platformNodeList, xmlNodeMethodList[n], EnableSimulator);
                                        }
                                    }
                                }));
                            }
                            else
                            {
                                LoadTipsControl.launchView = this;
                                if (mainWindow.wasLoadedTip)
                                {
                                    MessageBoxResult msbox = System.Windows.MessageBox.Show("可能有枪头未卸载，是否先卸载？", "提示", MessageBoxButton.YesNo);
                                    if (msbox == MessageBoxResult.Yes)
                                    {
                                        //调用执行方法,更新执行结果字符串
                                        UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                                        unloadTipsControl.launchView = this;
                                        unloadTipsControl.ExecuteUnloadTipsInToTrash(platformNodeList, xmlNodeMethodList[n], EnableSimulator);
                                    }
                                }

                                #region 计算加载Tip头后，Z轴多出来的长度
                                //XmlNodeList labwareNodeh = xmlDocument.SelectNodes("root/env/platform");
                                //Labware labwaresa = labwareBll.GetLabware(xmlNodeMethodList[n].SelectSingleNode("labwaretip/value").InnerText);
                                //currentLengthOfTip = (float)labwaresa.tip_length - (float)labwaresa.press_tipinto_depth;
                                //ControlCom.CurrentLengthOfTip= currentLengthOfTip;
                                #endregion
                            }

                            bool result = loadTipsControl.ExecuteLoadTips(xmlDocument.SelectNodes("root/env/platform"), xmlNodeMethodList[n], EnableSimulator);
                            if (!result)
                            {
                                return 0;
                            }
                            #region 计算加载Tip头后，Z轴多出来的长度
                            XmlNodeList labwareNode = xmlDocument.SelectNodes("root/env/platform");
                            Labware labwares = labwareBll.GetLabware(xmlNodeMethodList[n].SelectSingleNode("labwaretip/value").InnerText);
                            currentLengthOfTip = (float)labwares.tip_length - (float)labwares.press_tipinto_depth;
                            ControlCom.CurrentLengthOfTip = currentLengthOfTip;
                            ControlCom.CurrentTipLabware = labwares;
                            #endregion

                            //获取command list 中对应节点，恢复为原色表示运行结束
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.loop:              // 开始循环
                        #region 开始循环
                        {
                            int loopStartId = Convert.ToInt32(xmlNodeMethodList[n].Attributes["id"].InnerText);
                            string endIndex = xmlNodeMethodList[n].SelectSingleNode("endIndex").InnerText;
                            if (isLoop1Start == false)// && isLoop2Start == false)
                            {
                                isLoop1Start = true;
                                string strVariable1 = xmlNodeMethodList[n].SelectSingleNode("variableName").InnerText;
                                Variable variable = new Variable();
                                variable.variablename = strVariable1;
                                variable.variablecurval = xmlNodeMethodList[n].SelectSingleNode("variablesValue").InnerText;
                                variable.variableinitval = xmlNodeMethodList[n].SelectSingleNode("variablesValue").InnerText;
                                gloadVariable.Push(variable);
                                int sk1 = Convert.ToInt32(variable.variableinitval);
                                int aVariable = 0;//循环的结束值
                                string strVariable = xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText;
                                if (strVariable.Contains("&"))
                                {
                                    strVariable = strVariable.Substring(1, strVariable.Length - 1);
                                }

                                #region 循环的结束值，支持数值变量命令
                                bool result = VariableDictionary.TryGetValue(strVariable, out aVariable);
                                int ek1 = 0;
                                if (result && xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText.Contains("&"))
                                {
                                    ek1 = aVariable;
                                }
                                else if (!result && xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText.Contains("&"))
                                {
                                    PlsToolTipWin plsToolTipWin = new PlsToolTipWin("循环结束值不正确！");
                                    plsToolTipWin.Height = this.ActualHeight;
                                    plsToolTipWin.Width = this.ActualWidth;

                                    SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(70, 0, 0, 0));
                                    plsToolTipWin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                                    plsToolTipWin.btnCancel.Visibility = Visibility.Hidden;
                                    plsToolTipWin.ShowDialog();
                                    return 0;
                                }
                                else
                                {
                                    ek1 = Convert.ToInt32(xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText);
                                }
                                #endregion

                                int ik1 = Convert.ToInt32(xmlNodeMethodList[n].SelectSingleNode("incrementValue").InnerText);

                                Variable v = gloadVariable.Peek();
                                //找到此循环对应的结束的点，返回结束点的index
                                for (int i = sk1; i <= ek1; i = i + ik1)
                                {
                                    v.variablecurval = i.ToString();
                                    //gloadVariable.Push(v);
                                    int iq = ExecMethodList(xmlDocument, loopStartId + 1);
                                    if (iq == 0 || iq == 2)       // 失败、停止
                                    {
                                        return iq;
                                    }
                                    else if (iq == 3)              // skip
                                    {
                                        break;
                                    }
                                }
                                XmlNode xnd = xmlDocument.SelectSingleNode("root/method[strIndex='" + endIndex + "']");
                                ind = Convert.ToInt32(xnd.Attributes["id"].InnerText);
                                n = n + ind - loopStartId;

                                //记住当前n的值
                                //n = n + calculationTotalOfCmdInLoop()+1;//最外一层循环

                                isLoop1Start = false;
                            }
                            else if (isLoop1Start == true) //&& isLoop2Start == false)
                            {
                                Variable variable = new Variable();
                                variable.variablename = xmlNodeMethodList[n].SelectSingleNode("variableName").InnerText;
                                variable.variablecurval = xmlNodeMethodList[n].SelectSingleNode("variablesValue").InnerText;
                                variable.variableinitval = xmlNodeMethodList[n].SelectSingleNode("variablesValue").InnerText;
                                gloadVariable.Push(variable);

                                int sk2 = Convert.ToInt32(variable.variableinitval);
                                int ek2 = Convert.ToInt32(xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText);
                                int ik2 = Convert.ToInt32(xmlNodeMethodList[n].SelectSingleNode("incrementValue").InnerText);
                                //int ck2 = sk2;


                                for (int i = sk2; i <= ek2; i = i + ik2)
                                {
                                    //ck2 = i;
                                    int iq = ExecMethodList(xmlDocument, loopStartId + 1);
                                    if (iq == 0 || iq == 2)       // 失败、停止
                                    {
                                        return iq;
                                    }
                                    else if (iq == 3)              // skip
                                    {
                                        break;
                                    }
                                }
                                //isLoop2Start = false;

                                //返回到最外一层的循环
                                //return 1;
                            }
                            else if (isLoop1Start == true) //&& isLoop2Start == true)
                            {
                                //isLoop1Start = false;
                            }
                            else if (isLoop1Start == false) //&& isLoop2Start == true)
                            {
                                //isLoop1Start = false;
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.mixing:            // 混合
                        #region 混合
                        {
                            MixingControl mixingControl = new MixingControl(Shared.SoftwareInformation.currentculture);
                            mixingControl.launchView = this;
                            bool result = mixingControl.ExecuteMixing(xmlEnv, xmlNodeMethodList[n], currentLengthOfTip, zAxisSafeVal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.pause:             // 暂停
                        #region 暂停
                        {
                            //调用执行方法,更新执行结果字符串
                            PauseControl pauseControl = new PauseControl(Shared.SoftwareInformation.currentculture);
                            pauseControl.launchView = this;
                            bool result = pauseControl.ExecutePause(xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.remark:            // 备注
                        #region 备注
                        {
                            string title = xmlNodeMethodList[n].SelectSingleNode("title").InnerText;
                            string remark= xmlNodeMethodList[n].SelectSingleNode("remark").InnerText;

                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】" + Properties.Resources.strTips+":"+title+","+Properties.Resources.strTipsMsg+":"+remark);
                            }
                            else
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】title of mark: " + title + ", content or mark: " + remark);
                            }

                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】" + Properties.MachineRunResource.strProgress.ToString() + Properties.MachineRunResource.strEnd.ToString());
                            }
                            else
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】progress: completed.");
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.transferfile:      // 文件
                        #region 文件
                        {
                            //调用执行方法,更新执行结果字符串
                            TransferFileControl transferFileControl = new TransferFileControl(Shared.SoftwareInformation.currentculture);
                            transferFileControl.launchView = this;
                            bool result = transferFileControl.ExecuteTransferFile(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.unloadtips:        // 卸载吸头
                        #region 卸载吸头
                        {
                            // 调用执行方法,更新执行结果字符串
                            UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                            unloadTipsControl.launchView = this;
                            bool result = unloadTipsControl.ExecuteUnloadTips(xmlDocument.SelectNodes("root/env/platform"), xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                            currentWellLatticeId = string.Empty;
                            currentInValidWell = string.Empty;
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.setVariable:       //设置变量
                        #region 设置变量
                        {
                            // 调用执行方法,更新执行结果字符串
                            SetVariableControl setVariableControl = new SetVariableControl(Shared.SoftwareInformation.currentculture);
                            setVariableControl.launchView = this;
                            bool result = setVariableControl.ExecuteSetVariable(xmlEnv, xmlNodeMethodList[n]);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.dataexport:        // 数据导出
                        #region 数据导出
                        {
                            //调用执行方法,更新执行结果字符串
                            DataExportControl dataExportControl = new DataExportControl(Shared.SoftwareInformation.currentculture);
                            dataExportControl.launchView = this;
                            bool result = dataExportControl.ExecuteDataExport(xmlNodeMethodList[n], dataTableTotal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.coatingfile:       // 涂布文件
                        #region 涂布文件
                        {
                            // 调用执行方法,更新执行结果字符串
                            CoatingFileControl coatingFileControl = new CoatingFileControl(Shared.SoftwareInformation.currentculture);
                            coatingFileControl.launchView = this;
                            bool result = coatingFileControl.ExecuteCoatingFile(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.takephoto:         // 拍照
                        #region 拍照
                        {
                            // 调用执行方法,更新执行结果字符串
                            TakePhotoControl takePhotoControl = new TakePhotoControl();
                            takePhotoControl.launchView = this;
                            bool result = takePhotoControl.ExecuteTakePhoto(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.cutGum:       // 切胶文件
                        #region 切胶文件
                        {
                            // 调用执行方法,更新执行结果字符串
                            CutGumFileControl cutGumFileControl = new CutGumFileControl(Shared.SoftwareInformation.currentculture);
                            cutGumFileControl.launchView = this;
                            bool result = cutGumFileControl.ExecuteCoatingFile(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.coatingReport:     // 涂布报告
                        #region 涂布报告
                        {
                            // 调用执行方法,更新执行结果字符串
                            CoatingReportControl dataExportControl = new CoatingReportControl(Shared.SoftwareInformation.currentculture);
                            dataExportControl.launchView = this;
                            bool result = dataExportControl.ExecuteCoatingFileExport(xmlNodeMethodList[n], dataTableTotal, EnableSimulator);
                            if (!result)
                            {
                                return 0;
                            }
                            else
                            {
                                //发送涂布数据给中控
                                if (isRemotingOper)
                                {
                                }
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.ultrasonic:        // 超声探测
                        #region 超声探测
                        {
                            //调用执行方法,更新执行结果字符串
                            UltrasonicControl ultrasonicControl = new UltrasonicControl(Shared.SoftwareInformation.currentculture);
                            ultrasonicControl.launchView = this;
                            bool result = ultrasonicControl.ExecuteUltrasonic(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.choiceTransfer:    // 挑选转板
                        #region 挑选转板
                        {
                            // 调用执行方法
                            ChoiceTransferControl choiceTransferControl = new ChoiceTransferControl();
                            ChoiceTransferControl.LaunchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            int result = choiceTransferControl.ExecuteChoiceTransfer(xmlDocument, xmlNodeMethodList[n], EnableSimulator);

                            if (result == 0)
                            {
                                // 0：失败；1：成功；2：停止；3：skip
                                return 0;
                            }
                            else if (result == 1)
                            {
                                // 0：失败；1：成功；2：停止；3：skip
                                return 3;
                            }
                            else
                            {
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.coatingTransfer:   // 涂布转板
                        #region 涂布转板
                        {
                            // 调用执行方法
                            CoatingTransferControl coatingTransferControl = new CoatingTransferControl();
                            CoatingTransferControl.LaunchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            int result = coatingTransferControl.ExecuteCoatingTransfer(xmlEnv, xmlNodeMethodList[n], EnableSimulator);

                            if (result == 0)
                            {
                                // 0：失败；1：成功；2：停止；3：skip
                                return 0;
                            }
                            else if (result == 1)
                            {
                                // 0：失败；1：成功；2：停止；3：skip
                                return 3;
                            }
                            else
                            {
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.dilution:          // 梯度稀释
                        #region 梯度稀释
                        {
                            // 调用执行方法
                            DilutionControl dilutionControl = new DilutionControl();
                            DilutionControl.LaunchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            bool result = dilutionControl.ExecuteDilution(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.VariableImport:    //文件导入变量
                        #region 文件导入变量
                        {
                            // 调用执行方法
                            VariableImportControl variableImportControl = new VariableImportControl(Shared.SoftwareInformation.currentculture);
                            variableImportControl.launchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            bool result = variableImportControl.ExecuteVariableImport(xmlNodeMethodList[n]);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.ifStart:    //if开始
                        #region if开始
                        {
                            // 调用执行方法
                            IfElseControl ifElseControl = new IfElseControl(Shared.SoftwareInformation.currentculture);
                            ifElseControl.launchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            int result = ifElseControl.ExecuteIfElse(xmlNodeMethodList[n]);
                            if (result == -1) //有错终止
                            {
                                return 0;
                            }
                            else if (result == 0) //条件不满足
                            {
                                //跳过，直接执行else
                                string indexName = xmlNodeMethodList[n].SelectSingleNode("strIndex").InnerText;
                                string indexOfElse = string.Empty;
                                if (indexName.Contains("-"))
                                {
                                    string heardOfIndex = indexName.Substring(0, indexName.LastIndexOf("-"));
                                    string nextOfIndex = indexName.Substring(indexName.LastIndexOf("-") + 1, indexName.Length - indexName.LastIndexOf("-") - 1);
                                    indexOfElse = (heardOfIndex + "-" + (Convert.ToInt32(nextOfIndex) + 1)).ToString();
                                }
                                else
                                {
                                    indexOfElse = (Convert.ToInt32(indexName) + 1).ToString();
                                }

                                int indexOfNextNode = 0; //下个待执行节点索引
                                for(int i=n;i<xmlNodeMethodList.Count;i++)
                                {
                                    if (xmlNodeMethodList[i].SelectSingleNode("strIndex").InnerText== indexOfElse)
                                    {
                                        indexOfNextNode = i;
                                        break;
                                    }
                                }
                                if (indexOfNextNode > n)
                                {
                                    n = indexOfNextNode-2;
                                }
                            }
                            else if (result == 1) //条件满足
                            {
                                result = 1;//正常继续执行
                            }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.ifEnd:      //if结束
                        #region if结束
                        {
                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】" + Properties.MachineRunResource.strProgress.ToString() + Properties.MachineRunResource.strEnd.ToString());
                            }
                            else
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】progress: completed.");
                            }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.elseStart:    //else开始
                        #region else开始
                        {

                            // 调用执行方法
                            IfElseControl ifElseControl = new IfElseControl(Shared.SoftwareInformation.currentculture);
                            ifElseControl.launchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            int result = ifElseControl.ExecuteIfElse(xmlNodeMethodList[n]);
                            if (result == -1) //有错终止
                            {
                                return 0;
                            }
                            else if (result == 0) //条件不满足
                            {
                                //跳过，直接执行else
                                string indexName = xmlNodeMethodList[n].SelectSingleNode("strIndex").InnerText;
                                string indexOfElse = string.Empty;
                                if (indexName.Contains("-"))
                                {
                                    string heardOfIndex = indexName.Substring(0, indexName.LastIndexOf("-"));
                                    string nextOfIndex = indexName.Substring(indexName.LastIndexOf("-") + 1, indexName.Length - indexName.LastIndexOf("-") - 1);
                                    indexOfElse = (heardOfIndex + "-" + (Convert.ToInt32(nextOfIndex) + 1)).ToString();
                                }
                                else
                                {
                                    indexOfElse = (Convert.ToInt32(indexName) + 1).ToString();
                                }

                                int indexOfNextNode = 0; //下个待执行节点索引
                                for (int i = n; i < xmlNodeMethodList.Count; i++)
                                {
                                    if (xmlNodeMethodList[i].SelectSingleNode("strIndex").InnerText == indexOfElse)
                                    {
                                        indexOfNextNode = i;
                                        break;
                                    }
                                }
                                if (indexOfNextNode > n)
                                {
                                    n = indexOfNextNode - 2;
                                }
                            }
                            else if (result == 1) //条件满足
                            {
                                result = 1;//正常继续执行
                            }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.elseEnd:      //else结束
                        #region else 结束
                        #region else结束
                        {
                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】" + Properties.MachineRunResource.strProgress.ToString() + Properties.MachineRunResource.strEnd.ToString());
                            }
                            else
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】progress: completed.");
                            }
                        }
                        #endregion
                        #endregion
                        break;
                    case (int)MethodNameEnum.timerSet:     //timer计时器
                        #region 计时器
                        {
                            if(timeTimer==null)
                            {
                                timeTimer=new Timer(timerTimer_Tick, null, 0, 1000);
                            }

                            TimerControl timerControl = new TimerControl(Shared.SoftwareInformation.currentculture);
                            timerControl.launchView = this;
                            bool result = timerControl.ExecuteTimer(xmlEnv, xmlNodeMethodList[n], xmlDocument, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.waitFor:      //等待
                        #region 等待
                        {
                            Task.WaitAll(taskForSubmethod.ToArray());//等待并行结束
                            //调用执行方法,更新执行结果字符串
                            WaitForControl waitForControl = new WaitForControl(Shared.SoftwareInformation.currentculture);
                            waitForControl.launchView = this;
                            bool result = waitForControl.ExecuteWaitFor(xmlEnv, xmlNodeMethodList[n], xmlDocument, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.pumpDispense:          //泵排液
                        #region 泵排液
                        PumpDispenseControl pumpDispenseControl = new PumpDispenseControl(Shared.SoftwareInformation.currentculture);
                        pumpDispenseControl.launchView = this;
                        bResult = pumpDispenseControl.ExecutePumpDispense(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.shaker:          //振荡
                        #region 振荡
                        ShakeControl shakeControl = new ShakeControl(Shared.SoftwareInformation.currentculture);
                        shakeControl.launchView = this;
                        bResult = shakeControl.ExecuteShake(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.switchLid:          //开关盖
                        #region 开关盖
                        SwitchLidControl switchLidControl = new SwitchLidControl(Shared.SoftwareInformation.currentculture);
                        switchLidControl.launchView = this;
                        bResult = switchLidControl.ExecuteSwitchLid(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.fileMoveLiquid:          //文件开关盖移液
                        #region 文件开关盖移液
                        FileMoveLiquidControl fileMoveLiquidControl = new FileMoveLiquidControl(Shared.SoftwareInformation.currentculture);
                        fileMoveLiquidControl.launchView = this;
                        bResult = fileMoveLiquidControl.ExecuteFileMoveLiquid(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal,EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.fileMoveLabware:          //文件转板
                        #region 文件转板
                        FileMoveLabwareControl fileMoveLabwareControl = new FileMoveLabwareControl(Shared.SoftwareInformation.currentculture);
                        fileMoveLabwareControl.launchView = this;
                        bResult = fileMoveLabwareControl.ExecuteFileMoveLabware(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.varCalc:       //变量计算
                        #region 变量计算
                        {
                            // 调用执行方法,更新执行结果字符串
                            VarCalcControl varCalcControl = new VarCalcControl();
                            varCalcControl.launchView = this;
                            bool result = varCalcControl.Execute(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.subMethod:             // 子方法
                        #region 子方法
                        {
                            SubMethodControl subMethodControl = new SubMethodControl();
                            subMethodControl.launchView = this;
                            bResult = subMethodControl.Execute(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!bResult) { return 0; }
                        }
                        #endregion
                        break;
                    default:
                        {
                            int totalpause = 0;
                            if(!IsRunning)
                            {
                                return 2;
                            }
                            while (pauseState == 1)   //仅提供给暂停使用
                            {
                                Thread.Sleep(1000);
                                AddLogs("暂停"+(++totalpause).ToString()+"s");
                            }
                            if (_cancelSource.IsCancellationRequested)
                            {
                                return 2;
                            }
                            XmlNode isThirdPartXmlNode = xmlNodeMethodList[n].SelectSingleNode("isThirdPart");
                            if (isThirdPartXmlNode != null && bool.Parse(isThirdPartXmlNode.InnerText))     // 第三方设备
                            {
                                bool result = ExecThirdPart(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                                if (!result) { return 0; }
                            }
                        }
                        break;
                }
            }
            return resultExc;
        }

        #region 执行流程中的方法---专为并行使用
        /// <summary>
        /// 执行流程中方法
        /// </summary>
        /// <param name="xmlDocument"></param>
        /// <param name="startId"></param>
        /// <returns>0：失败；1：成功；2：停止；3：skip</returns>
        public int ExecMethodListForCombine(XmlDocument xmlDocument, int startId)
        {
            int resultExc = 1;
            // 方法
            XmlNodeList xmlNodeMethodList = xmlDocument.SelectNodes("root/method[@id>=" + startId + "]");
            XmlNode xmlEnv = xmlDocument.SelectSingleNode("root/env");
            var platformNodeList = xmlEnv.SelectNodes("platform");
            bool bResult = false;
            int ind = 0;

            //生成运行时台面所有板位上的对象数据

            // 清空方法列表
            for (int n = 0; n < xmlNodeMethodList.Count; n++)
            {
                string MethodName = xmlNodeMethodList[n].SelectSingleNode("label").InnerText;
                workStack.Push(MethodName);
                string id = xmlNodeMethodList[n].Attributes["id"].Value.ToString();
                string strIndex = xmlNodeMethodList[n].SelectSingleNode("strIndex").InnerText;
                float xAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["xAxisSafeVal"]);
                float yAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["yAxisSafeVal"]);
                float zAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["zAxisSafeVal"]);

                int iNum = methodListBll.getNumByMethodName(MethodName);
                if (_cancelSource.IsCancellationRequested)
                {
                    _cancelSource = new CancellationTokenSource();
                    return 2;
                }

                if (xmlNodeMethodList[n].SelectSingleNode("status") == null)
                {
                    continue;
                }

                if (xmlNodeMethodList[n].SelectSingleNode("status").InnerText != "enable")
                {
                    continue;
                }

                if (selectedMethodEx == null)
                {

                }
                else if (ExistNodeByNodeIndex(selectedMethodEx, strIndex))
                {

                }
                else if (!ExistNodeByNodeIndex(selectedMethodEx, strIndex))
                {
                    continue;
                }

                // 设置节点状态
                SetRunningStatus(strIndex);

                switch (iNum)
                {
                    case (int)MethodNameEnum.start:             // 开始
                        #region 开始
                        lstCoatingLabware = null;      // 清空涂布使用的所有目标耗材板

                        string usehepa = xmlNodeMethodList[n].SelectSingleNode("usehepa").InnerText;
                        string isReset = xmlNodeMethodList[n].SelectSingleNode("isreset").InnerText;
                        string isCheckTakePhotoPlate = xmlNodeMethodList[n].SelectSingleNode("isCheckTakePhotoPlate").InnerText;

                        #region 复位
                        bool isOk = DoRest(this, isReset, xmlNodeMethodList[n]);
                        if (!isOk)
                        {
                            return 2;
                        }
                        #endregion

                        #region 检查成像板位是否有板
                        if (ConfigurationManager.AppSettings["openTakePhoto"].ToString() == "true")
                        {
                            isOk = DoCheckTakePhotoPlate(isCheckTakePhotoPlate, EnableSimulator);
                            if (!isOk)
                            {
                                return 2;
                            }
                        }
                        #endregion
                        #endregion
                        break;

                    case (int)MethodNameEnum.aspirate:          // 吸液
                        #region 吸液
                        AspirateControl aspirateControl = new AspirateControl(Shared.SoftwareInformation.currentculture);
                        aspirateControl.launchView = this;
                        bResult = aspirateControl.ExecuteAspirate(xmlEnv, xmlNodeMethodList[n], currentLengthOfTip, zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;

                    case (int)MethodNameEnum.dispense:          // 排液
                        #region 排液
                        DispenseControl dispenseControl = new DispenseControl(Shared.SoftwareInformation.currentculture);
                        dispenseControl.launchView = this;
                        // 是否在循环中，当前循环的
                        bResult = dispenseControl.ExecuteDispense(xmlEnv, xmlNodeMethodList[n], currentLengthOfTip, zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;

                    case (int)MethodNameEnum.end:               // 结束
                        #region 结束
                        lstCoatingLabware = null;      // 清空涂布使用的所有目标耗材板
                        ChoiceTransferControl.ChoiceData = null;
                        CoatingTransferControl.CoatingData = null;

                        string isGoHome = xmlNodeMethodList[n].SelectSingleNode("isGoHome").InnerText;
                        string isTipsOff = xmlNodeMethodList[n].SelectSingleNode("isTipsOff").InnerText;
                        if (!isRemotingOper)
                        {
                            if (mainWindow.wasLoadedTip)//抢上有枪头，需要卸载
                            {
                                if (isTipsOff.ToLower() == "true")
                                {
                                    //调用执行方法,更新执行结果字符串
                                    UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                                    unloadTipsControl.launchView = this;
                                    unloadTipsControl.ExecuteUnloadTipsInToTrash(platformNodeList, xmlNodeMethodList[n], EnableSimulator);
                                }
                            }
                        }

                        if (isGoHome.ToLower() == "true")
                        {
                            //调用复位
                            //判断是否有未卸载的枪头
                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strStartReset));
                            }
                            else
                            {
                                AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), "start reset"));
                            }

                            //判断是否有未卸载的枪头                           
                            //判断是否有抓取中的板子
                            if (!isRemotingOper)
                            {
                                if (mainWindow.wasLoadedTip)//抢上有枪头，需要卸载
                                {
                                    if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                                    {
                                        AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.RunUnloadTipsResource.strUnloadTip));
                                    }
                                    else
                                    {
                                        AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), "unload tip"));
                                    }
                                }
                            }

                            ////调用复位方法全部轴复位回零
                            //if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            //{
                            //    AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strGoHome));
                            //}
                            //else
                            //{
                            //    AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), "go home"));
                            //}

                            //调用执行方法,更新执行结果字符串
                            HomeControl homeControl = new HomeControl(Shared.SoftwareInformation.currentculture);
                            homeControl.launchView = this;

                            bResult = homeControl.ExecuteHome(xmlNodeMethodList[n], xAxisSafeVal, yAxisSafeVal, zAxisSafeVal, EnableSimulator);
                            if (!bResult) { return 0; }
                        }

                        // 状态3 待机 蓝色
                        CommonBll.StatusLamp(3, EnableSimulator);
                        #endregion
                        break;

                    case (int)MethodNameEnum.endgroup:          // 结束组合
                        #region 结束组合
                        ind = Convert.ToInt32(xmlNodeMethodList[n].Attributes["id"].Value.ToString());
                        return ind;
                    #endregion

                    case (int)MethodNameEnum.endloop:           // 结束循环
                        #region 结束循环
                        {
                            if (isLoop1Start == false)//&& isLoop2Start == false)
                            {
                            }
                            else if (isLoop1Start == true)// && isLoop2Start == false)
                            {
                                //n = n + calculationTotalOfCmdInLoop() + 1;//最外一层循环
                                //isLoop1Start = false;
                                return 1;
                            }
                            else if (isLoop1Start == true)// && isLoop2Start == true)
                            {
                                //isLoop2Start = false;
                                return 1;
                            }
                            else if (isLoop1Start == false)// && isLoop2Start == true)
                            {
                                //isLoop1Start = false;
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.griptransport:     // 抓板转移
                        #region 抓板转移
                        {
                            GripTransportControl gripTransportControl = new GripTransportControl(Shared.SoftwareInformation.currentculture);
                            gripTransportControl.launchView = this;
                            if (isRemotingOper)
                            {
                                gripTransportControl.socketTcpListener = ((MainWindow)Application.Current.MainWindow).socketTcpListener;
                            }
                            else
                            {
                                gripTransportControl.socketTcpListener = mainWindow.socketTcpListener;
                            }
                            bool result = gripTransportControl.ExecuteGripTransport(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.holdingLabware:     // 夹爪保持开始
                        #region 夹爪保持开始
                        {
                            HoldingLabwareControl holdingLabwareControl = new HoldingLabwareControl(Shared.SoftwareInformation.currentculture);
                            holdingLabwareControl.LaunchView = this;
                            if (isRemotingOper)
                            {
                                holdingLabwareControl.SocketTcpListener = ((MainWindow)Application.Current.MainWindow).socketTcpListener;
                            }
                            else
                            {
                                holdingLabwareControl.SocketTcpListener = mainWindow.socketTcpListener;
                            }
                            bool result = holdingLabwareControl.ExecuteBeginHolding(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.endHoldingLabware:     // 夹爪保持结束
                        #region 夹爪保持结束
                        {
                            HoldingLabwareControl holdingLabwareControl = new HoldingLabwareControl(Shared.SoftwareInformation.currentculture);
                            holdingLabwareControl.LaunchView = this;
                            if (isRemotingOper)
                            {
                                holdingLabwareControl.SocketTcpListener = ((MainWindow)Application.Current.MainWindow).socketTcpListener;
                            }
                            else
                            {
                                holdingLabwareControl.SocketTcpListener = mainWindow.socketTcpListener;
                            }
                            bool result = holdingLabwareControl.ExecuteEndHolding(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.group:             // 组合
                        #region 组合
                        {
                            int loopStartId = Convert.ToInt32(xmlNodeMethodList[n].Attributes["id"].InnerText);
                            ind = ExecMethodList(xmlDocument, loopStartId + 1);
                            if (ind == 0 || ind == 2)       // 失败、停止
                            {
                                return ind;
                            }
                            else if (ind == 3)              // skip
                            {
                            }

                            //记住当前n的值
                            n = n + ind - loopStartId;
                            //n = n + calculationTotalOfCmdInGroup() + 1;//最外一层组合
                        }
                        #endregion

                        break;
                    case (int)MethodNameEnum.home:              // 复位
                        #region 复位
                        {
                            //调用复位
                            //判断是否有未卸载的枪头
                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strStartReset));
                            }
                            else
                            {
                                AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), "start reset"));
                            }

                            //判断是否有未卸载的枪头                           
                            //判断是否有抓取中的板子
                            if (!isRemotingOper)
                            {
                                if (mainWindow.wasLoadedTip)//抢上有枪头，需要卸载
                                {
                                    if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                                    {
                                        AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.RunUnloadTipsResource.strUnloadTip));
                                    }
                                    else
                                    {
                                        AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), "unload tip"));
                                    }
                                }
                            }

                            //调用复位方法全部轴复位回零
                            //if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            //{
                            //    AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strGoHome));
                            //}
                            //else
                            //{
                            //    AddLogs(string.Format("【{0}】> {1}", DateTime.Now.ToString("HH:mm:ss:fff"), "go home"));
                            //}

                            //调用执行方法,更新执行结果字符串
                            HomeControl homeControl = new HomeControl(Shared.SoftwareInformation.currentculture);
                            homeControl.launchView = this;

                            bResult = homeControl.ExecuteHome(xmlNodeMethodList[n], xAxisSafeVal, yAxisSafeVal, zAxisSafeVal, EnableSimulator);
                            if (!bResult) { return 0; }
                            CommonBll.StatusLamp(4, EnableSimulator);
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.loadtips:          // 安装吸头
                        #region 安装吸头
                        {
                            if (_cancelSource.IsCancellationRequested)
                            {
                                return 2;
                            }

                            //调用执行方法,更新执行结果字符串
                            LoadTipsControl loadTipsControl = new LoadTipsControl(Shared.SoftwareInformation.currentculture);
                            if (!isRemotingOper)
                            {
                                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                                {
                                    LoadTipsControl.launchView = this;

                                    if (mainWindow.wasLoadedTip)
                                    {
                                        MessageBoxResult msbox = System.Windows.MessageBox.Show("可能有枪头未卸载，是否先卸载？", "提示", MessageBoxButton.YesNo);
                                        if (msbox == MessageBoxResult.Yes)
                                        {
                                            //调用执行方法,更新执行结果字符串
                                            UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                                            unloadTipsControl.launchView = this;
                                            unloadTipsControl.ExecuteUnloadTipsInToTrash(platformNodeList, xmlNodeMethodList[n], EnableSimulator);
                                        }
                                    }
                                }));
                            }
                            else
                            {
                                LoadTipsControl.launchView = this;
                                if (mainWindow.wasLoadedTip)
                                {
                                    MessageBoxResult msbox = System.Windows.MessageBox.Show("可能有枪头未卸载，是否先卸载？", "提示", MessageBoxButton.YesNo);
                                    if (msbox == MessageBoxResult.Yes)
                                    {
                                        //调用执行方法,更新执行结果字符串
                                        UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                                        unloadTipsControl.launchView = this;
                                        unloadTipsControl.ExecuteUnloadTipsInToTrash(platformNodeList, xmlNodeMethodList[n], EnableSimulator);
                                    }
                                }

                                #region 计算加载Tip头后，Z轴多出来的长度
                                //XmlNodeList labwareNodeh = xmlDocument.SelectNodes("root/env/platform");
                                //Labware labwaresa = labwareBll.GetLabware(xmlNodeMethodList[n].SelectSingleNode("labwaretip/value").InnerText);
                                //currentLengthOfTip = (float)labwaresa.tip_length - (float)labwaresa.press_tipinto_depth;
                                //ControlCom.CurrentLengthOfTip= currentLengthOfTip;
                                #endregion
                            }

                            bool result = loadTipsControl.ExecuteLoadTips(xmlDocument.SelectNodes("root/env/platform"), xmlNodeMethodList[n], EnableSimulator);
                            if (!result)
                            {
                                return 0;
                            }
                            #region 计算加载Tip头后，Z轴多出来的长度
                            XmlNodeList labwareNode = xmlDocument.SelectNodes("root/env/platform");
                            Labware labwares = labwareBll.GetLabware(xmlNodeMethodList[n].SelectSingleNode("labwaretip/value").InnerText);
                            currentLengthOfTip = (float)labwares.tip_length - (float)labwares.press_tipinto_depth;
                            ControlCom.CurrentLengthOfTip = currentLengthOfTip;
                            ControlCom.CurrentTipLabware = labwares;
                            #endregion

                            //获取command list 中对应节点，恢复为原色表示运行结束
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.loop:              // 开始循环
                        #region 开始循环
                        {
                            int loopStartId = Convert.ToInt32(xmlNodeMethodList[n].Attributes["id"].InnerText);
                            string endIndex = xmlNodeMethodList[n].SelectSingleNode("endIndex").InnerText;
                            if (isLoop1Start == false)// && isLoop2Start == false)
                            {
                                isLoop1Start = true;
                                string strVariable1 = xmlNodeMethodList[n].SelectSingleNode("variableName").InnerText;
                                Variable variable = new Variable();
                                variable.variablename = strVariable1;
                                variable.variablecurval = xmlNodeMethodList[n].SelectSingleNode("variablesValue").InnerText;
                                variable.variableinitval = xmlNodeMethodList[n].SelectSingleNode("variablesValue").InnerText;
                                gloadVariable.Push(variable);
                                int sk1 = Convert.ToInt32(variable.variableinitval);
                                int aVariable = 0;//循环的结束值
                                string strVariable = xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText;
                                if (strVariable.Contains("&"))
                                {
                                    strVariable = strVariable.Substring(1, strVariable.Length - 1);
                                }

                                #region 循环的结束值，支持数值变量命令
                                bool result = VariableDictionary.TryGetValue(strVariable, out aVariable);
                                int ek1 = 0;
                                if (result && xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText.Contains("&"))
                                {
                                    ek1 = aVariable;
                                }
                                else if (!result && xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText.Contains("&"))
                                {
                                    PlsToolTipWin plsToolTipWin = new PlsToolTipWin("循环结束值不正确！");
                                    plsToolTipWin.Height = this.ActualHeight;
                                    plsToolTipWin.Width = this.ActualWidth;

                                    SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(70, 0, 0, 0));
                                    plsToolTipWin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                                    plsToolTipWin.btnCancel.Visibility = Visibility.Hidden;
                                    plsToolTipWin.ShowDialog();
                                    return 0;
                                }
                                else
                                {
                                    ek1 = Convert.ToInt32(xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText);
                                }
                                #endregion

                                int ik1 = Convert.ToInt32(xmlNodeMethodList[n].SelectSingleNode("incrementValue").InnerText);

                                Variable v = gloadVariable.Peek();
                                //找到此循环对应的结束的点，返回结束点的index
                                for (int i = sk1; i <= ek1; i = i + ik1)
                                {
                                    v.variablecurval = i.ToString();
                                    //gloadVariable.Push(v);
                                    int iq = ExecMethodListForCombine(xmlDocument, loopStartId + 1);
                                    if (iq == 0 || iq == 2)       // 失败、停止
                                    {
                                        return iq;
                                    }
                                    else if (iq == 3)              // skip
                                    {
                                        break;
                                    }
                                }
                                XmlNode xnd = xmlDocument.SelectSingleNode("root/method[strIndex='" + endIndex + "']");
                                ind = Convert.ToInt32(xnd.Attributes["id"].InnerText);
                                n = n + ind - loopStartId;

                                //记住当前n的值
                                //n = n + calculationTotalOfCmdInLoop()+1;//最外一层循环

                                isLoop1Start = false;
                            }
                            else if (isLoop1Start == true) //&& isLoop2Start == false)
                            {
                                Variable variable = new Variable();
                                variable.variablename = xmlNodeMethodList[n].SelectSingleNode("variableName").InnerText;
                                variable.variablecurval = xmlNodeMethodList[n].SelectSingleNode("variablesValue").InnerText;
                                variable.variableinitval = xmlNodeMethodList[n].SelectSingleNode("variablesValue").InnerText;
                                gloadVariable.Push(variable);

                                int sk2 = Convert.ToInt32(variable.variableinitval);
                                int ek2 = Convert.ToInt32(xmlNodeMethodList[n].SelectSingleNode("variableeValue").InnerText);
                                int ik2 = Convert.ToInt32(xmlNodeMethodList[n].SelectSingleNode("incrementValue").InnerText);
                                //int ck2 = sk2;


                                for (int i = sk2; i <= ek2; i = i + ik2)
                                {
                                    //ck2 = i;
                                    int iq = ExecMethodListForCombine(xmlDocument, loopStartId + 1);
                                    if (iq == 0 || iq == 2)       // 失败、停止
                                    {
                                        return iq;
                                    }
                                    else if (iq == 3)              // skip
                                    {
                                        break;
                                    }
                                }
                                //isLoop2Start = false;

                                //返回到最外一层的循环
                                //return 1;
                            }
                            else if (isLoop1Start == true) //&& isLoop2Start == true)
                            {
                                //isLoop1Start = false;
                            }
                            else if (isLoop1Start == false) //&& isLoop2Start == true)
                            {
                                //isLoop1Start = false;
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.mixing:            // 混合
                        #region 混合
                        {
                            MixingControl mixingControl = new MixingControl(Shared.SoftwareInformation.currentculture);
                            mixingControl.launchView = this;
                            bool result = mixingControl.ExecuteMixing(xmlEnv, xmlNodeMethodList[n], currentLengthOfTip, zAxisSafeVal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.pause:             // 暂停
                        #region 暂停
                        {
                            //调用执行方法,更新执行结果字符串
                            PauseControl pauseControl = new PauseControl(Shared.SoftwareInformation.currentculture);
                            pauseControl.launchView = this;
                            bool result = pauseControl.ExecutePause(xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.remark:            // 备注
                        #region 备注
                        {
                            string title = xmlNodeMethodList[n].SelectSingleNode("title").InnerText;
                            string remark = xmlNodeMethodList[n].SelectSingleNode("remark").InnerText;

                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】" + Properties.Resources.strTips + ":" + title + "," + Properties.Resources.strTipsMsg + ":" + remark);
                            }
                            else
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】title of mark: " + title + ", content or mark: " + remark);
                            }

                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】" + Properties.MachineRunResource.strProgress.ToString() + Properties.MachineRunResource.strEnd.ToString());
                            }
                            else
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】progress: completed.");
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.transferfile:      // 文件
                        #region 文件
                        {
                            //调用执行方法,更新执行结果字符串
                            TransferFileControl transferFileControl = new TransferFileControl(Shared.SoftwareInformation.currentculture);
                            transferFileControl.launchView = this;
                            bool result = transferFileControl.ExecuteTransferFile(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.unloadtips:        // 卸载吸头
                        #region 卸载吸头
                        {
                            // 调用执行方法,更新执行结果字符串
                            UnloadTipsControl unloadTipsControl = new UnloadTipsControl(Shared.SoftwareInformation.currentculture);
                            unloadTipsControl.launchView = this;
                            bool result = unloadTipsControl.ExecuteUnloadTips(xmlDocument.SelectNodes("root/env/platform"), xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                            currentWellLatticeId = string.Empty;
                            currentInValidWell = string.Empty;
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.setVariable:       //设置变量
                        #region 设置变量
                        {
                            // 调用执行方法,更新执行结果字符串
                            SetVariableControl setVariableControl = new SetVariableControl(Shared.SoftwareInformation.currentculture);
                            setVariableControl.launchView = this;
                            bool result = setVariableControl.ExecuteSetVariable(xmlEnv, xmlNodeMethodList[n]);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.dataexport:        // 数据导出
                        #region 数据导出
                        {
                            //调用执行方法,更新执行结果字符串
                            DataExportControl dataExportControl = new DataExportControl(Shared.SoftwareInformation.currentculture);
                            dataExportControl.launchView = this;
                            bool result = dataExportControl.ExecuteDataExport(xmlNodeMethodList[n], dataTableTotal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.coatingfile:       // 涂布文件
                        #region 涂布文件
                        {
                            // 调用执行方法,更新执行结果字符串
                            CoatingFileControl coatingFileControl = new CoatingFileControl(Shared.SoftwareInformation.currentculture);
                            coatingFileControl.launchView = this;
                            bool result = coatingFileControl.ExecuteCoatingFile(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.takephoto:         // 拍照
                        #region 拍照
                        {
                            // 调用执行方法,更新执行结果字符串
                            TakePhotoControl takePhotoControl = new TakePhotoControl();
                            takePhotoControl.launchView = this;
                            bool result = takePhotoControl.ExecuteTakePhoto(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.coatingReport:     // 涂布报告
                        #region 涂布报告
                        {
                            // 调用执行方法,更新执行结果字符串
                            CoatingReportControl dataExportControl = new CoatingReportControl(Shared.SoftwareInformation.currentculture);
                            dataExportControl.launchView = this;
                            bool result = dataExportControl.ExecuteCoatingFileExport(xmlNodeMethodList[n], dataTableTotal, EnableSimulator);
                            if (!result)
                            {
                                return 0;
                            }
                            else
                            {
                                //发送涂布数据给中控
                                if (isRemotingOper)
                                {
                                }
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.ultrasonic:        // 超声探测
                        #region 超声探测
                        {
                            //调用执行方法,更新执行结果字符串
                            UltrasonicControl ultrasonicControl = new UltrasonicControl(Shared.SoftwareInformation.currentculture);
                            ultrasonicControl.launchView = this;
                            bool result = ultrasonicControl.ExecuteUltrasonic(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.choiceTransfer:    // 挑选转板
                        #region 挑选转板
                        {
                            // 调用执行方法
                            ChoiceTransferControl choiceTransferControl = new ChoiceTransferControl();
                            ChoiceTransferControl.LaunchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            int result = choiceTransferControl.ExecuteChoiceTransfer(xmlDocument, xmlNodeMethodList[n], EnableSimulator);

                            if (result == 0)
                            {
                                // 0：失败；1：成功；2：停止；3：skip
                                return 0;
                            }
                            else if (result == 1)
                            {
                                // 0：失败；1：成功；2：停止；3：skip
                                return 3;
                            }
                            else
                            {
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.coatingTransfer:   // 涂布转板
                        #region 涂布转板
                        {
                            // 调用执行方法
                            CoatingTransferControl coatingTransferControl = new CoatingTransferControl();
                            CoatingTransferControl.LaunchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            int result = coatingTransferControl.ExecuteCoatingTransfer(xmlEnv, xmlNodeMethodList[n], EnableSimulator);

                            if (result == 0)
                            {
                                // 0：失败；1：成功；2：停止；3：skip
                                return 0;
                            }
                            else if (result == 1)
                            {
                                // 0：失败；1：成功；2：停止；3：skip
                                return 3;
                            }
                            else
                            {
                            }
                        }
                        #endregion
                        break;

                    case (int)MethodNameEnum.dilution:          // 梯度稀释
                        #region 梯度稀释
                        {
                            // 调用执行方法
                            DilutionControl dilutionControl = new DilutionControl();
                            DilutionControl.LaunchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            bool result = dilutionControl.ExecuteDilution(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.VariableImport:    //文件导入变量
                        #region 文件导入变量
                        {
                            // 调用执行方法
                            VariableImportControl variableImportControl = new VariableImportControl(Shared.SoftwareInformation.currentculture);
                            variableImportControl.launchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            bool result = variableImportControl.ExecuteVariableImport(xmlNodeMethodList[n]);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.ifStart:    //if开始
                        #region if开始
                        {
                            // 调用执行方法
                            IfElseControl ifElseControl = new IfElseControl(Shared.SoftwareInformation.currentculture);
                            ifElseControl.launchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            int result = ifElseControl.ExecuteIfElse(xmlNodeMethodList[n]);
                            if (result == -1) //有错终止
                            {
                                return 0;
                            }
                            else if (result == 0) //条件不满足
                            {
                                //跳过，直接执行else
                                string indexName = xmlNodeMethodList[n].SelectSingleNode("strIndex").InnerText;
                                string indexOfElse = string.Empty;
                                if (indexName.Contains("-"))
                                {
                                    string heardOfIndex = indexName.Substring(0, indexName.LastIndexOf("-"));
                                    string nextOfIndex = indexName.Substring(indexName.LastIndexOf("-") + 1, indexName.Length - indexName.LastIndexOf("-") - 1);
                                    indexOfElse = (heardOfIndex + "-" + (Convert.ToInt32(nextOfIndex) + 1)).ToString();
                                }
                                else
                                {
                                    indexOfElse = (Convert.ToInt32(indexName) + 1).ToString();
                                }

                                int indexOfNextNode = 0; //下个待执行节点索引
                                for (int i = n; i < xmlNodeMethodList.Count; i++)
                                {
                                    if (xmlNodeMethodList[i].SelectSingleNode("strIndex").InnerText == indexOfElse)
                                    {
                                        indexOfNextNode = i;
                                        break;
                                    }
                                }
                                if (indexOfNextNode > n)
                                {
                                    n = indexOfNextNode - 2;
                                }
                            }
                            else if (result == 1) //条件满足
                            {
                                result = 1;//正常继续执行
                            }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.ifEnd:      //if结束
                        #region if结束
                        {
                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】" + Properties.MachineRunResource.strProgress.ToString() + Properties.MachineRunResource.strEnd.ToString());
                            }
                            else
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】progress: completed.");
                            }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.elseStart:    //else开始
                        #region else开始
                        {

                            // 调用执行方法
                            IfElseControl ifElseControl = new IfElseControl(Shared.SoftwareInformation.currentculture);
                            ifElseControl.launchView = this;
                            // 0:异常结束, 1:正常继续，2:正常结束
                            int result = ifElseControl.ExecuteIfElse(xmlNodeMethodList[n]);
                            if (result == -1) //有错终止
                            {
                                return 0;
                            }
                            else if (result == 0) //条件不满足
                            {
                                //跳过，直接执行else
                                string indexName = xmlNodeMethodList[n].SelectSingleNode("strIndex").InnerText;
                                string indexOfElse = string.Empty;
                                if (indexName.Contains("-"))
                                {
                                    string heardOfIndex = indexName.Substring(0, indexName.LastIndexOf("-"));
                                    string nextOfIndex = indexName.Substring(indexName.LastIndexOf("-") + 1, indexName.Length - indexName.LastIndexOf("-") - 1);
                                    indexOfElse = (heardOfIndex + "-" + (Convert.ToInt32(nextOfIndex) + 1)).ToString();
                                }
                                else
                                {
                                    indexOfElse = (Convert.ToInt32(indexName) + 1).ToString();
                                }

                                int indexOfNextNode = 0; //下个待执行节点索引
                                for (int i = n; i < xmlNodeMethodList.Count; i++)
                                {
                                    if (xmlNodeMethodList[i].SelectSingleNode("strIndex").InnerText == indexOfElse)
                                    {
                                        indexOfNextNode = i;
                                        break;
                                    }
                                }
                                if (indexOfNextNode > n)
                                {
                                    n = indexOfNextNode - 2;
                                }
                            }
                            else if (result == 1) //条件满足
                            {
                                result = 1;//正常继续执行
                            }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.elseEnd:      //else结束
                        #region else 结束
                        #region else结束
                        {
                            if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】" + Properties.MachineRunResource.strProgress.ToString() + Properties.MachineRunResource.strEnd.ToString());
                            }
                            else
                            {
                                AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + xmlNodeMethodList[n].SelectSingleNode("name").InnerText + "】progress: completed.");
                            }
                        }
                        #endregion
                        #endregion
                        break;
                    case (int)MethodNameEnum.timerSet:     //timer计时器
                        #region 计时器
                        {
                            if (timeTimer == null)
                            {
                                timeTimer = new Timer(timerTimer_Tick, null, 0, 1000);
                            }

                            TimerControl timerControl = new TimerControl(Shared.SoftwareInformation.currentculture);
                            timerControl.launchView = this;
                            bool result = timerControl.ExecuteTimer(xmlEnv, xmlNodeMethodList[n], xmlDocument, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.waitFor:      //等待
                        #region 等待
                        {
                            //调用执行方法,更新执行结果字符串
                            WaitForControl waitForControl = new WaitForControl(Shared.SoftwareInformation.currentculture);
                            waitForControl.launchView = this;
                            bool result = waitForControl.ExecuteWaitFor(xmlEnv, xmlNodeMethodList[n], xmlDocument, EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.pumpDispense:          //泵排液
                        #region 泵排液
                        PumpDispenseControl pumpDispenseControl = new PumpDispenseControl(Shared.SoftwareInformation.currentculture);
                        pumpDispenseControl.launchView = this;
                        bResult = pumpDispenseControl.ExecutePumpDispense(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.shaker:          //振荡
                        #region 振荡
                        ShakeControl shakeControl = new ShakeControl(Shared.SoftwareInformation.currentculture);
                        shakeControl.launchView = this;
                        bResult = shakeControl.ExecuteShake(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.switchLid:          //开关盖
                        #region 开关盖
                        SwitchLidControl switchLidControl = new SwitchLidControl(Shared.SoftwareInformation.currentculture);
                        switchLidControl.launchView = this;
                        bResult = switchLidControl.ExecuteSwitchLid(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.fileMoveLiquid:          //文件开关盖移液
                        #region 文件开关盖移液
                        FileMoveLiquidControl fileMoveLiquidControl = new FileMoveLiquidControl(Shared.SoftwareInformation.currentculture);
                        fileMoveLiquidControl.launchView = this;
                        bResult = fileMoveLiquidControl.ExecuteFileMoveLiquid(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.fileMoveLabware:          //文件转板
                        #region 文件转板
                        FileMoveLabwareControl fileMoveLabwareControl = new FileMoveLabwareControl(Shared.SoftwareInformation.currentculture);
                        fileMoveLabwareControl.launchView = this;
                        bResult = fileMoveLabwareControl.ExecuteFileMoveLabware(xmlEnv, xmlNodeMethodList[n], zAxisSafeVal, EnableSimulator);
                        if (!bResult) { return 0; }
                        #endregion
                        break;
                    case (int)MethodNameEnum.varCalc:       //变量计算
                        #region 变量计算
                        {
                            // 调用执行方法,更新执行结果字符串
                            VarCalcControl varCalcControl = new VarCalcControl();
                            varCalcControl.launchView = this;
                            bool result = varCalcControl.Execute(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!result) { return 0; }
                        }
                        #endregion
                        break;
                    case (int)MethodNameEnum.subMethod:             // 子方法
                        #region 子方法
                        {
                            SubMethodControl subMethodControl = new SubMethodControl();
                            subMethodControl.launchView = this;
                            bResult = subMethodControl.Execute(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                            if (!bResult) { return 0; }
                        }
                        #endregion
                        break;
                    default:
                        #region 第三方设备
                        {
                            while(pauseState==1)   //仅提供给暂停使用
                            {
                                Thread.Sleep(1000);
                                //AddLogs("暂停");
                            }
                            if (_cancelSource.IsCancellationRequested)
                            {
                                return 2;
                            }
                            XmlNode isThirdPartXmlNode = xmlNodeMethodList[n].SelectSingleNode("isThirdPart");
                            if (isThirdPartXmlNode != null && bool.Parse(isThirdPartXmlNode.InnerText))     // 第三方设备
                            {
                                bool result = ExecThirdPart(xmlEnv, xmlNodeMethodList[n], EnableSimulator);
                                if (!result) { return 0; }
                            }
                        }
                        #endregion
                        break;
                }
            }
            return resultExc;
        }
        #endregion

        #region 定时器事件--计时器每秒减少1s
        private void timerTimer_Tick(object sender)
        {
            try
            {
                lock (methodTimers)
                {
                    List<MethodTimer> methodTimerEnds = new List<MethodTimer>();//存储计时结束的计时器对象
                    foreach (MethodTimer t in methodTimers)
                    {
                        if (Convert.ToDouble(t.duringTime) > 0)
                        {
                            t.duringTime = (Convert.ToDouble(t.duringTime) - 1d).ToString();
                        }
                        else
                        {
                            AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + t.name + "】" + "计时结束");
                            methodTimerEnds.Add(t);
                        }
                    }

                    foreach(MethodTimer t in methodTimerEnds)
                    {
                        methodTimers.Remove(t);
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("[timerTimer_Tick]:ERROR:", ex);
            }
        }
        #endregion

        #region 查找当前的节点编号是否在要运行的单节点中
        /// <summary>
        /// 查找当前的节点编号是否在要运行的单节点中
        /// </summary>
        /// <param name="currentMethodEx">当前节点对象</param>
        /// <param name="strIndex">待查找节点编号</param>
        /// <returns>true:存在;false: 不存在</returns>
        public bool ExistNodeByNodeIndex(MethodEx currentMethodEx,string strIndex)
        {
            bool result = false;
            if(currentMethodEx != null)
            {
                if(currentMethodEx.strIndex.Equals(strIndex))
                {
                    result= true;
                    return result;
                }
                else
                {
                    if(currentMethodEx.Children.Count>0)
                    {
                        foreach(MethodEx methodEx in currentMethodEx.Children)
                        {
                            result=ExistNodeByNodeIndex(methodEx, strIndex);
                            if(result)
                            {
                                return result;
                            }
                        }
                    }
                    
                }
            }
            return result;
        }
        #endregion

        /// <summary>
        /// 执行【第三方设备】指令
        /// </summary>
        /// <returns></returns>
        private bool ExecThirdPart(XmlNode xmlEnv, XmlNode currentNode, bool EnableSimulator)
        {
            // 调用执行方法
            ThirdPartControl thirdPartControl = new ThirdPartControl();
            ThirdPartControl.LaunchView = this;
            return thirdPartControl.ExecuteCoatingTransfer(xmlEnv, currentNode, EnableSimulator);
        }

        /// <summary>
        /// 检查成像板位是否有板
        /// </summary>
        /// <param name="isCheckTakePhotoPlate"></param>
        /// <param name="EnableSimulator"></param>
        /// <returns></returns>
        private bool DoCheckTakePhotoPlate(string isCheckTakePhotoPlate, bool EnableSimulator)
        {
            bool isOk = true;

            if (isCheckTakePhotoPlate.ToLower() == "true" && !EnableSimulator)
            {
                PlsToolTipWin checkSafeRuningDialog = null;
                bool bIsError = false;

                Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    string strMsg = string.Empty;
                    if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                    {
                        strMsg = Properties.TackPhotoResource.strCheckingSafe.ToString();
                    }
                    else
                    {
                        strMsg = "The action of check safe is executing...";
                    }

                    checkSafeRuningDialog = new PlsToolTipWin(strMsg);
                    checkSafeRuningDialog.Height = 200;
                    checkSafeRuningDialog.Width = 520;

                    SolidColorBrush mybtn2_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(0, 0, 0, 0));
                    checkSafeRuningDialog.Background = (System.Windows.Media.Brush)mybtn2_Brush;
                    checkSafeRuningDialog.btnCancel.Visibility = Visibility.Collapsed;
                    checkSafeRuningDialog.btnOK.Visibility = Visibility.Collapsed;
                    checkSafeRuningDialog.btnClose.Visibility = Visibility.Collapsed;
                    checkSafeRuningDialog.Show();

                    takePhotoBll.socketTcpListener = mainWindow.socketTcpListener;
                    bIsError = takePhotoBll.DoCheckSafe();

                    // 关闭运行页面
                    checkSafeRuningDialog.Close();
                }));

                if (bIsError)
                {
                    Application.Current.Dispatcher.Invoke(new Action(() =>
                    {
                        // 状态6 报错/急停 红闪/蜂鸣5S；
                        CommonBll.StatusLamp(6, EnableSimulator);

                        PlsToolTipWin plsToolTipWin = new PlsToolTipWin("拍照位存在未取走的板，请手动拿走后再启动实验！");
                        plsToolTipWin.Height = this.ActualHeight;
                        plsToolTipWin.Width = this.ActualWidth;

                        SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(0, 0, 0, 0));
                        plsToolTipWin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                        plsToolTipWin.btnCancel.Visibility = Visibility.Hidden;
                        plsToolTipWin.ShowDialog();
                    }));
                    isOk = false;
                }
            }

            return isOk;
        }

        /// <summary>
        /// 复位
        /// </summary>
        /// <param name="launchView"></param>
        /// <param name="isReset"></param>
        /// <param name="methodNode"></param>
        /// <returns></returns>
        private bool DoRest(RunWnd launchView, string isReset, XmlNode methodNode)
        {
            if (launchView._cancelSource.IsCancellationRequested)
            {
                return false;
            }

            if (isReset.ToLower() == "true")
            {
                #region 开始复位日志
                if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                {
                    AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strStartRest));
                }
                else
                {
                    AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), "start reset"));
                }
                #endregion

                #region 复位
                ////调用复位方法全部轴复位回零
                //if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                //{
                //    AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), Properties.MachineRunResource.strGoHome));
                //}
                //else
                //{
                //    AddLogs(string.Format("【{0}】> {1}.", DateTime.Now.ToString("HH:mm:ss:fff"), "go home"));
                //}

                HomeControl homeControl = new HomeControl(Shared.SoftwareInformation.currentculture);
                homeControl.launchView = this;
                float xAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["xAxisSafeVal"]);
                float yAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["yAxisSafeVal"]);
                float zAxisSafeVal = (float)Convert.ToDouble(ConfigurationManager.AppSettings["zAxisSafeVal"]);
                string deviceNumber = "";

                bool result = homeControl.ExecuteHome(methodNode, xAxisSafeVal, yAxisSafeVal, zAxisSafeVal, EnableSimulator);
                if (!result) { return false; }
                #endregion

                #region 判断是否有枪头并卸载枪头
                //int retN = ControlCom.ExecuteADPCheckTip(this, EnableSimulator);
                //if (retN == 2)       // 检查正常 && 有枪头
                //{
                //    return false;
                //}
                #endregion

                #region 初始化外部jaka机械臂
                //// 枪头卸载成功后再复位
                //result = homeControl.ExecuteHome(methodNode, xAxisSafeVal, yAxisSafeVal, zAxisSafeVal, EnableSimulator);
                //if (!result) { return false; }

                #endregion

                #region Choice
                if (Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceChoice)
                {
                    if (!isRemotingOper)
                    {
                        if (mainWindow != null)
                        {
                            if (mainWindow.socketTcpListener != null && mainWindow.socketTcpListener.IsConnect())
                            {
                                MethodMsg methodMsgS = new MethodMsg(Guid.NewGuid().ToString(), "ID202_Choice_machine", 2, "", "ClawOpen", "", "", 1, 0);
                                // 拍照
                                mainWindow.socketTcpListener.SendMessage(mainWindow.socketTcpListener.CreateSendOpenCraw(methodMsgS), true);
                                System.Threading.Thread.Sleep(5000);
                            }
                        }
                    }
                    else
                    {
                    }
                }
                #endregion

                // 状态4 运行 绿色
                CommonBll.StatusLamp(4, EnableSimulator);
            }

            return true;
        }

        #region 查找当前是否有已经使用的Tip保存的文件
        public List<DropdownName> GetUsedTipFromXML()
        {
            List<DropdownName> dropdownNames = new List<DropdownName>();
            XmlDocument xmlDocument = new XmlDocument();
            try
            {
                string directoryBase = System.AppDomain.CurrentDomain.BaseDirectory;
                string xmlFilePath = directoryBase + "Config\\" + "CurrentUsedTips.xml";
                if (File.Exists(xmlFilePath))
                {
                    xmlDocument.Load(xmlFilePath);
                    XmlNodeList xnList = xmlDocument.SelectNodes("root/data/tipdata");
                    if (xnList != null && xnList.Count > 0)
                    {
                        foreach (XmlNode xn in xnList)
                        {
                            DropdownName dropdown = new DropdownName();
                            dropdown.dropdown_id = xn.SelectSingleNode("lattice_id").InnerText;
                            dropdown.dropdown_name = xn.SelectSingleNode("wellname").InnerText;
                            dropdownNames.Add(dropdown);
                        }
                    }
                }
                else
                {
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
            return dropdownNames;
        }
        #endregion

        #region 保存当前的枪头盒子信息到xml文件中
        public int SaveUsedTipInfoIntoXML(List<DropdownName> dropdownNames)
        {
            LoggerRunHelper.InfoLog("当前已使用的Tip头孔位数据集个数" + dropdownNames.Count.ToString());
            List<DropdownName> oldDropdownName = this.GetUsedTipFromXML();//读取上次的数据

            foreach (DropdownName ddn in oldDropdownName)
            {
                DropdownName ddnew = new DropdownName();
                ddnew.dropdown_id = ddn.dropdown_id;
                ddnew.dropdown_name = ddn.dropdown_name;

                var selectOne = dropdownNames.FirstOrDefault(x => x.dropdown_id.Equals(ddn.dropdown_id) && x.dropdown_name.Equals(ddn.dropdown_name));
                if (selectOne == null || selectOne.dropdown_id == "")
                {
                    dropdownNames.Add(ddnew);
                }
            }
            LoggerRunHelper.InfoLog("当前已使用的Tip头孔位数据集更新后的个数" + dropdownNames.Count.ToString());

            XmlDocument xmlDoc = new XmlDocument();
            XmlElement root;
            XmlDeclaration dec = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", null);
            xmlDoc.AppendChild(dec);
            root = xmlDoc.CreateElement("root");
            xmlDoc.AppendChild(root);

            XmlElement xeKey = xmlDoc.CreateElement("data");//创建子节点，并且设置子节点的属性

            foreach (DropdownName dropdownName in dropdownNames)
            {
                XmlElement xeformX = xmlDoc.CreateElement("tipdata");

                XmlElement xeformX1 = xmlDoc.CreateElement("lattice_id");
                xeformX1.InnerText = dropdownName.dropdown_id;
                xeformX.AppendChild(xeformX1);

                xeformX1 = xmlDoc.CreateElement("wellname");
                xeformX1.InnerText = dropdownName.dropdown_name;
                xeformX.AppendChild(xeformX1);
                xeKey.AppendChild(xeformX);
            }
            root.AppendChild(xeKey);//挂载父节点

            int iresult = 0;
            try
            {
                if (xmlDoc.SelectNodes("root/data/tipdata") != null && xmlDoc.SelectNodes("root/data/tipdata").Count > 0)
                {
                    //xmlDoc.Save(filePath.Split('.')[0] + ".xml");//保存xml文件
                    //File.Move(filePath.Split('.')[0] + ".xml", filePath.Split('.')[0] + ".mod");
                    string directoryBase = System.AppDomain.CurrentDomain.BaseDirectory;
                    string xmlFilePath = directoryBase + "Config\\" + "CurrentUsedTips.xml";
                    if (File.Exists(xmlFilePath))
                    {
                        File.Delete(xmlFilePath);
                        LoggerRunHelper.InfoLog("当前已使用的Tip头孔位数据集保存前删除旧的文件");
                        xmlDoc.Save(xmlFilePath);
                        LoggerRunHelper.InfoLog("当前已使用的Tip头孔位数据集保存文件");
                    }
                    else
                    {
                        xmlDoc.Save(xmlFilePath);
                        LoggerRunHelper.InfoLog("当前已使用的Tip头孔位数据集保存文件");
                    }
                    iresult = 1;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                iresult = 0;
            }
            return iresult;
        }
        #endregion

        Stack<string> workStack = new Stack<string>();//用来保存流程命令序列
        #region 计算本次循环内的命令个数
        private int calculationTotalOfCmdInLoop()
        {
            int icount = 0;
            for (int i = 0; i < workStack.Count; i++)
            {
                string name = workStack.Pop();
                if (i == 0 && name == "Method_EndLoop")
                {

                }
                else
                {
                    if (name != "循环开始" && name != "Method_EndLoop")
                    {
                        icount = icount + 1;
                    }
                    else if (name == "循环开始" || name == "Method_EndLoop")
                    {
                        break;
                    }
                }
            }
            return icount;
        }
        #endregion

        #region 计算本次组合内的命令个数
        private int calculationTotalOfCmdInGroup()
        {
            int icount = 0;
            for (int i = 0; i < workStack.Count; i++)
            {
                string name = workStack.Pop();
                if (i == 0 && name == "Method_EndGroup")
                {

                }
                else
                {
                    if (name != "组合开始" && name != "Method_EndGroup")
                    {
                        icount = icount + 1;
                    }
                    else if (name == "组合开始" || name == "Method_EndGroup")
                    {
                        name = workStack.Pop();
                        while (name != "循环开始")
                        {
                            workStack.Pop();
                        }
                        break;
                    }
                }
            }
            return icount;
        }
        #endregion

        public int GetIndex(XmlDocument xmlDocument, int startId, int mark)
        {
            int iResult = 0;
            XmlNodeList xmlNodeMethodList = xmlDocument.SelectNodes("root/method[@id>=" + startId + "]");
            int totalOfLoop = 1;//嵌套的for循环次数

            //清空方法列表
            for (int n = 0; n < xmlNodeMethodList.Count; n++)
            {
                string MethodName = xmlNodeMethodList[n].SelectSingleNode("name").InnerText;

                int iNum = methodListBll.getNumByMethodName(MethodName);
                workStack.Push(MethodName);
                switch (iNum)
                {
                    case (int)MethodNameEnum.loop:
                        {
                            if (isLoop1Start == false)// && isLoop2Start == false)
                            {
                            }
                            else if (isLoop1Start == true)// && isLoop2Start == false)
                            {
                                //isLoop2Start = true;
                                totalOfLoop = totalOfLoop + 1;
                                //iResult = n;
                                //return iResult;
                            }
                            else if (isLoop1Start == true)// && isLoop2Start == true)
                            {
                                //isLoop2Start = false;
                            }
                            else if (isLoop1Start == false)// && isLoop2Start == true)
                            {
                                //isLoop1Start = false;
                            }
                        }
                        break;
                    case (int)MethodNameEnum.endloop:
                        {
                            if (isLoop1Start == false)// && isLoop2Start == false)
                            {
                            }
                            else if (isLoop1Start == true)// && isLoop2Start == false)
                            {
                                //isLoop1Start = false;
                                iResult = n;
                                return iResult;
                            }
                            else if (isLoop1Start == true)// && isLoop2Start == true)
                            {
                                if (totalOfLoop >= 2)
                                {
                                    //isLoop2Start = false;
                                    if (mark == 2)
                                    {
                                        iResult = n;
                                        return iResult;
                                    }
                                }

                            }
                            else if (isLoop1Start == false)// && isLoop2Start == true)
                            {
                                //isLoop1Start = false;
                            }
                        }
                        break;
                    default:
                        break;
                }
            }
            return iResult;
        }

        #region 更新指定xml节点上的单枪头
        /// <summary>
        /// 更新指定xml节点上的单枪头
        /// </summary>
        /// <param name="tipsTable">枪头运行属性实体对象</param>
        public void UpdateLabwaretips(TipsTable tipsTable)
        {
            if (!isRemotingOper)
            {
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    if (xmlDocument != null)
                    {
                        int pid = 0;
                        if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceX1))
                        {
                            if (Convert.ToInt32(tipsTable.lattice_id) > 20)
                            {
                                pid = Convert.ToInt32(tipsTable.lattice_id) - 66;
                            }
                        }
                        else if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLiteChoice) ||
                        Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200))
                        {
                            Lattice lattice = LatticeDB.GetLatticeDataByIdFromdb(tipsTable.lattice_id);
                            pid = Convert.ToInt32(lattice.lattice_num.Substring(1));// ControlCom.GetLatticeId(Convert.ToInt32(tipsTable.lattice_id), false);
                        }
                        else if(Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceHXFX))
                        {
                            //Lattice lattice = LatticeDB.GetLatticeDataByIdFromdb(tipsTable.lattice_num,Convert.ToInt32(Shared.DeviceArmList.FirstOrDefault(x=>x.arm_type.Equals(1))).device_arm_id,Shared.SoftwareInformation.software_device_number);
                            pid = Convert.ToInt32(tipsTable.lattice_num.Substring(1));// ControlCom.GetLatticeId(Convert.ToInt32(tipsTable.lattice_id), false);
                        }
                        else if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceHXELEC))
                        {
                            //Lattice lattice = LatticeDB.GetLatticeDataByIdFromdb(tipsTable.lattice_num,Convert.ToInt32(Shared.DeviceArmList.FirstOrDefault(x=>x.arm_type.Equals(1))).device_arm_id,Shared.SoftwareInformation.software_device_number);
                            pid = Convert.ToInt32(tipsTable.lattice_num.Substring(1));// ControlCom.GetLatticeId(Convert.ToInt32(tipsTable.lattice_id), false);
                        }
                        else
                        {
                            pid = Convert.ToInt32(tipsTable.lattice_id);
                        }

                        XmlNodeList xList = xmlDocument.SelectNodes("root/env/platform[lattice_id='" + pid + "']/labware");
                        XmlNode x = xmlDocument.SelectSingleNode("root/env/platform[lattice_id='" + pid + "']/labware[@id='"+ xList.Count + "'][labware_id='" + tipsTable.labware_id + "']");
                        string wells = x.SelectSingleNode("residueValidWells").InnerText;
                        List<string> swell = wells.Split(',').ToList();

                        // 去掉当前正在使用的Tip头位置
                        if (swell.Contains(tipsTable.wellname))
                        {
                            swell.Remove(tipsTable.wellname);
                            DropdownName currentAWellLattice = new DropdownName();
                            currentAWellLattice.dropdown_id = tipsTable.lattice_id;
                            currentAWellLattice.dropdown_name = tipsTable.wellname;
                            currentIsUsedWellLattice.Add(currentAWellLattice);
                        }
                        wells = string.Empty;

                        // 组装使用后剩余的位置
                        for (int i = 0; i < swell.Count; i++)
                        {
                            wells += swell[i] + ",";
                        }
                        if(wells.Length>0)
                        {
                            wells= wells.Substring(0,wells.Length-1);
                        }
                        if (!string.IsNullOrEmpty(wells))
                        {
                            x.SelectSingleNode("residueValidWells").InnerText = wells;
                        }
                        else
                        {
                            x.SelectSingleNode("residueValidWells").InnerText = "";
                        }

                        foreach (var lb in labwareList)
                        {
                            int row = lb.row;
                            int col = lb.col;

                            // 获取台面对应格子的Canvas
                            Canvas canvas = null;
                            TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                            if (tabletopTemplate == null)
                            {
                                canvas = GetGridTableCanvas(row, col);
                            }
                            else
                            {
                                canvas = GetCanvasByLatticeNumOfLabware(lb);
                            }

                            if (canvas == null)
                            {
                                continue;
                            }

                            ControlLabware control = Utilities.FindVisualChild<ControlLabware>(canvas);
                            LabwareEx labwareEx = control.DataContext as LabwareEx;
                            if (lb.label.Equals(tipsTable.lattice_num))
                            {
                                control.ValidWells = wells;
                                labwareEx.validWells = wells;
                            }

                            ////更新 设计界面的对应格子的Canvas
                            //Canvas canvasDesign = this.GetGridTableCanvasOnDesign(row, col);
                            Canvas canvasDesign = null;
                            tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                            if (tabletopTemplate == null)
                            {
                                canvasDesign = GetGridTableCanvasOnDesign(row, col);
                            }
                            else
                            {
                                canvasDesign = GetCanvasByLatticeNumOfLabwareMainForm(lb);
                            }
                            if (canvasDesign == null)
                            {
                                continue;
                            }

                            ControlLabware controlDesign = Utilities.FindVisualChild<ControlLabware>(canvasDesign);
                            labwareEx = canvasDesign.DataContext as LabwareEx;
                            if (lb.label.Equals(tipsTable.lattice_num))
                            {
                                controlDesign.ValidWells = wells;
                                labwareEx.validWells = wells;
                            }
                        }
                    }
                }));
            }
            else
            {
                if (xmlDocument != null)
                {
                    int pid = Convert.ToInt32(tipsTable.lattice_id);
                    XmlNodeList xList = xmlDocument.SelectNodes("root/env/platform[lattice_id='" + pid + "']/labware");
                    XmlNode x = xmlDocument.SelectSingleNode("root/env/platform[lattice_id='" + pid + "']/labware[@id='"+ xList.Count + "'][labware_id='" + tipsTable.labware_id + "']");
                    string wells = x.SelectSingleNode("residueValidWells").InnerText;
                    List<string> swell = wells.Split(',').ToList();

                    if (swell.Contains(tipsTable.wellname))
                    {
                        swell.Remove(tipsTable.wellname);
                        DropdownName currentAWellLattice = new DropdownName();
                        currentAWellLattice.dropdown_id = tipsTable.lattice_id;
                        currentAWellLattice.dropdown_name = tipsTable.wellname;
                        currentIsUsedWellLattice.Add(currentAWellLattice);
                        if (isRemotingOper)
                        {
                            this.SaveUsedTipInfoIntoXML(currentIsUsedWellLattice);
                        }
                    }
                    wells = string.Empty;

                    for (int i = 0; i < swell.Count; i++)
                    {
                        wells += swell[i] + ",";
                    }
                    if (!string.IsNullOrEmpty(wells))
                    {
                        x.SelectSingleNode("residueValidWells").InnerText = wells;
                    }
                    else
                    {
                        x.SelectSingleNode("residueValidWells").InnerText = "";
                    }
                }
            }
        }
        #endregion

        #region 更新指定xml节点上的单孔位
        /// <summary>
        /// 更新指定xml节点上的单孔位
        /// </summary>
        /// <param name="tipsTable">枪头运行属性实体对象</param>
        /// <param name="wells"></param>
        /// <param name="markOfColor">孔位状态类型:1 无效孔白色；2：正在吸液红色；3：正在放液水红色；4：放液完成绿色；5：有效未使用蓝色</param>
        public void UpdateLabwareWells(TipsTable tipsTable, string[] wells, int markOfColor)
        {
            if (!isRemotingOper)
            {
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    if (xmlDocument != null)
                    {
                        Lattice lattice = LatticeDB.GetLatticeDataByIdFromdb(tipsTable.lattice_id);
                        int lapid = Convert.ToInt32(lattice.lattice_num.Substring(1));// ControlCom.GetLatticeId(Convert.ToInt32(tipsTable.lattice_id), false);
                        XmlNodeList xList = xmlDocument.SelectNodes("root/env/platform[lattice_id='" + lapid + "']/labware");
                        XmlNode x = xmlDocument.SelectSingleNode("root/env/platform[lattice_id='" + lapid.ToString() + "']/labware[@id='"+ xList.Count + "'][labware_id='" + tipsTable.labware_id + "']");

                        string swell = string.Empty;
                        for (int i = 0; i < wells.Length; i++)
                        {
                            swell += wells[i] + ",";
                        }
                        if (swell.Length > 0)
                        {
                            swell = swell.Substring(0, swell.Length - 1);
                        }

                        foreach (var lb in labwareList)
                        {
                            int row = lb.row;
                            int col = lb.col;

                            // 获取台面对应格子的Canvas
                            Canvas canvas = null;
                            TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                            if (tabletopTemplate == null)
                            {
                                canvas = GetGridTableCanvas(row, col);
                            }
                            else
                            {
                                canvas = GetCanvasByLatticeNumOfLabware(lb);
                            }

                            if (canvas == null)
                            {
                                continue;
                            }

                            ControlLabware control = Utilities.FindVisualChild<ControlLabware>(canvas);
                            if (lb.label.Equals(tipsTable.lattice_num))
                            {
                                if (markOfColor == 1)
                                {
                                    control.UpdateWells(swell, Brushes.White.Color);
                                }
                                else if (markOfColor == 2)
                                {
                                    control.UpdateWells(swell, Brushes.Red.Color);
                                }
                                else if (markOfColor == 3)
                                {
                                    SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 128, 255, 255));
                                    control.UpdateWells(swell, Brushes.Pink.Color);
                                }
                                else if (markOfColor == 4)
                                {
                                    SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 128, 255, 255));
                                    control.UpdateWells(swell, mybtn1_Brush.Color);
                                }
                                else if (markOfColor == 5)
                                {
                                    control.UpdateWells(swell, Color.FromArgb(0xFF, 0x0E, 0x81, 0xEC));
                                }
                            }
                        }
                    }
                }));
            }
            else
            {

            }
        }
        #endregion

        #region 更新指定xml节点上的8通道枪头
        /// <summary>
        /// 更新指定xml节点上的8通道枪头
        /// </summary>
        /// <param name="tipsTable">枪头运行属性实体对象</param>
        /// <param name="strWell">已使用枪头名称串组</param>
        public void UpdateLabwaretips(TipsTable tipsTable, string strWell)
        {
            if (!isRemotingOper)
            {
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    if (xmlDocument != null)
                    {
                        Lattice lattice = LatticeDB.GetLatticeDataByIdFromdb(tipsTable.lattice_id);
                        int lapid = Convert.ToInt32(lattice.lattice_num.Substring(1));//ControlCom.GetLatticeId(Convert.ToInt32(tipsTable.lattice_id), false);
                        XmlNodeList xList = xmlDocument.SelectNodes("root/env/platform[lattice_id='" + lapid + "']/labware");
                        XmlNode x = xmlDocument.SelectSingleNode("root/env/platform[lattice_id='" + lapid + "']/labware[@id='"+ xList.Count + "'][labware_id='" + tipsTable.labware_id + "']");
                        string wells = x.SelectSingleNode("residueValidWells").InnerText;
                        List<string> swell = wells.Split(',').ToList();
                        List<string> chWells = strWell.Split(',').ToList();
                        string Inwells = string.Empty;
                        for (int i = 0; i < chWells.Count; i++)
                        {
                            if (swell.Contains(chWells[i]))
                            {
                                swell.Remove(chWells[i]);
                                DropdownName currentAWellLattice = new DropdownName();
                                currentAWellLattice.dropdown_id = tipsTable.lattice_id;
                                currentAWellLattice.dropdown_name = chWells[i];
                                currentIsUsedWellLattice.Add(currentAWellLattice);
                              
                                Inwells += chWells[i] + ",";
                            }
                        }
                        Inwells = Inwells.Substring(0, Inwells.Length - 1);
                        wells = string.Empty;

                        for (int i = 0; i < swell.Count; i++)
                        {
                            wells += swell[i] + ",";
                        }
                        if (wells.Length > 0)
                        {
                            wells = wells.Substring(0, wells.Length - 1);
                        }
                        if (!string.IsNullOrEmpty(wells))
                        {
                            x.SelectSingleNode("residueValidWells").InnerText = wells;
                        }
                        else
                        {
                            x.SelectSingleNode("residueValidWells").InnerText = "";
                        }

                        foreach (var lb in labwareList)
                        {
                            int row = lb.row;
                            int col = lb.col;

                            // 获取台面对应格子的Canvas
                            Canvas canvas = null;
                            TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                            if (tabletopTemplate == null)
                            {
                                canvas = GetGridTableCanvas(row, col);
                            }
                            else
                            {
                                canvas = GetCanvasByLatticeNumOfLabware(lb);
                            }

                            if (canvas == null)
                            {
                                continue;
                            }

                            ControlLabware control = Utilities.FindVisualChild<ControlLabware>(canvas);
                            if (lb.label.Equals(tipsTable.lattice_num))
                            {
                                control.ValidWells = wells;
                            }

                            //Canvas canvasDesign = this.GetGridTableCanvasOnDesign(row, col);
                            Canvas canvasDesign = null;
                            tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                            if (tabletopTemplate == null)
                            {
                                canvasDesign = GetGridTableCanvasOnDesign(row, col);
                            }
                            else
                            {
                                canvasDesign = GetCanvasByLatticeNumOfLabware(lb);
                            }
                            if (canvasDesign == null)
                            {
                                continue;
                            }

                            ControlLabware controlDesign = Utilities.FindVisualChild<ControlLabware>(canvasDesign);
                            LabwareEx labwareEx = canvasDesign.DataContext as LabwareEx;
                            if (lb.label.Equals(tipsTable.lattice_num))
                            {
                                controlDesign.ValidWells = wells;
                                labwareEx.validWells = wells;
                            }
                        }
                    }
                }));
            }
            else
            {
                if (xmlDocument != null)
                {
                    Lattice lattice = LatticeDB.GetLatticeDataByIdFromdb(tipsTable.lattice_id);
                    int lapid = Convert.ToInt32(lattice.lattice_num.Substring(1));//ControlCom.GetLatticeId(Convert.ToInt32(tipsTable.lattice_id), false);
                    XmlNodeList xList = xmlDocument.SelectNodes("root/env/platform[lattice_id='" + lapid + "']/labware");
                    XmlNode x = xmlDocument.SelectSingleNode("root/env/platform[lattice_id='" + lapid + "']/labware[@id='"+ xList.Count + "'][labware_id='" + tipsTable.labware_id + "']");
                    string wells = x.SelectSingleNode("residueValidWells").InnerText;
                    List<string> swell = wells.Split(',').ToList();
                    List<string> chWells = strWell.Split(',').ToList();
                    string Inwells = string.Empty;
                    for (int i = 0; i < chWells.Count; i++)
                    {
                        if (swell.Contains(chWells[i]))
                        {
                            swell.Remove(chWells[i]);
                            DropdownName currentAWellLattice = new DropdownName();
                            currentAWellLattice.dropdown_id = tipsTable.lattice_id;
                            currentAWellLattice.dropdown_name = chWells[i];
                            currentIsUsedWellLattice.Add(currentAWellLattice);
                            if (isRemotingOper)
                            {
                                this.SaveUsedTipInfoIntoXML(currentIsUsedWellLattice);
                            }
                            Inwells += chWells[i] + ",";
                        }
                    }
                    Inwells = Inwells.Substring(0, Inwells.Length - 1);
                    wells = string.Empty;

                    for (int i = 0; i < swell.Count; i++)
                    {
                        wells += swell[i] + ",";
                    }
                    if (wells.Length > 0)
                    {
                        wells = wells.Substring(0, wells.Length - 1);
                    }
                    if (!string.IsNullOrEmpty(wells))
                    {
                        x.SelectSingleNode("residueValidWells").InnerText = wells;
                    }
                    else
                    {
                        x.SelectSingleNode("residueValidWells").InnerText = "";
                    }
                }
            }
        }
        #endregion

        #region 更新指定xml节点上的8通道枪头，放回原孔
        /// <summary>
        /// 更新指定xml节点上的8通道枪头，放回原孔
        /// </summary>
        /// <param name="tipsTable">枪头运行属性实体对象</param>
        /// <param name="strWell">已放回枪头名称串组</param>
        public void UpdateLabwaretipsPutIntoSrc(TipsTable tipsTable, string strWell)
        {
            if (!isRemotingOper)
            {
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    if (xmlDocument != null)
                    {
                        Lattice lattice = LatticeDB.GetLatticeDataByIdFromdb(tipsTable.lattice_id);
                        int lapid = Convert.ToInt32(lattice.lattice_num.Substring(1));//ControlCom.GetLatticeId(Convert.ToInt32(tipsTable.lattice_id), false);
                        XmlNodeList xList = xmlDocument.SelectNodes("root/env/platform[lattice_id='" + lapid + "']/labware");
                        XmlNode x = xmlDocument.SelectSingleNode("root/env/platform[lattice_id='" + lapid.ToString() + "']/labware[@id='"+ xList.Count + "'][labware_id='" + tipsTable.labware_id + "']");
                        string wells = x.SelectSingleNode("residueValidWells").InnerText;
                        List<string> swell = wells.Split(',').ToList();
                        List<string> chWells = strWell.Split(',').ToList();
                        string Inwells = string.Empty;
                        for (int i = 0; i < chWells.Count; i++)
                        {
                            if (!swell.Contains(chWells[i]))
                            {
                                swell.Add(chWells[i]);
                            }
                        }
                        wells = string.Empty;

                        for (int i = 0; i < swell.Count; i++)
                        {
                            wells += swell[i] + ",";
                        }
                        if (wells.Length > 0)
                        {
                            wells = wells.Substring(0, wells.Length - 1);
                        }
                        if (!string.IsNullOrEmpty(wells))
                        {
                            x.SelectSingleNode("residueValidWells").InnerText = wells;
                        }
                        else
                        {
                            x.SelectSingleNode("residueValidWells").InnerText = "";
                        }

                        foreach (var lb in labwareList)
                        {
                            int row = lb.row;
                            int col = lb.col;
                            //int pos = col * Shared.SoftwareInformation.rows + row;
                            //Canvas canvas = gridTable.Children[pos] as Canvas;

                            // 获取台面对应格子的Canvas
                            Canvas canvas = null;
                            TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                            if (tabletopTemplate == null)
                            {
                                canvas = GetGridTableCanvas(row, col);
                            }
                            else
                            {
                                canvas = GetCanvasByLatticeNumOfLabware(lb);
                            }

                            if (canvas == null)
                            {
                                continue;
                            }

                            ControlLabware control = Utilities.FindVisualChild<ControlLabware>(canvas);
                            if (lb.label.Equals(tipsTable.lattice_num))
                            {
                                control.ValidWells = wells;
                                //control.InValidWells = "";
                            }

                            //更新 设计界面的对应格子的Canvas
                            //Canvas canvasDesign = this.GetGridTableCanvasOnDesign(row, col);
                            // 获取台面对应格子的Canvas
                            Canvas canvasDesign = null;
                            tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                            if (tabletopTemplate == null)
                            {
                                canvasDesign = GetGridTableCanvasOnDesign(row, col);
                            }
                            else
                            {
                                canvasDesign = GetCanvasByLatticeNumOfLabwareMainForm(lb);
                            }

                            if (canvasDesign == null)
                            {
                                continue;
                            }

                            ControlLabware controlDesign = Utilities.FindVisualChild<ControlLabware>(canvasDesign);
                            LabwareEx labwareEx = canvasDesign.DataContext as LabwareEx;
                            if (lb.label.Equals(tipsTable.lattice_num))
                            {
                                controlDesign.ValidWells = wells;
                                labwareEx.validWells = wells;
                            }
                        }
                    }
                }));
            }
            else
            {
                if (xmlDocument != null)
                {
                    Lattice lattice = LatticeDB.GetLatticeDataByIdFromdb(tipsTable.lattice_id);
                    int lapid = Convert.ToInt32(lattice.lattice_num.Substring(1));// ControlCom.GetLatticeId(Convert.ToInt32(tipsTable.lattice_id), false);
                    XmlNodeList xList = xmlDocument.SelectNodes("root/env/platform[lattice_id='" + lapid + "']/labware");
                    XmlNode x = xmlDocument.SelectSingleNode("root/env/platform[lattice_id='" + lapid.ToString() + "']/labware[@id='"+ xList.Count + "'][labware_id='" + tipsTable.labware_id + "']");
                    string wells = x.SelectSingleNode("residueValidWells").InnerText;
                    List<string> swell = wells.Split(',').ToList();
                    List<string> chWells = strWell.Split(',').ToList();
                    string Inwells = string.Empty;
                    for (int i = 0; i < chWells.Count; i++)
                    {
                        if (!swell.Contains(chWells[i]))
                        {
                            swell.Add(chWells[i]);
                        }
                    }
                    wells = string.Empty;

                    for (int i = 0; i < swell.Count; i++)
                    {
                        wells += swell[i] + ",";
                    }
                    if (wells.Length > 0)
                    {
                        wells = wells.Substring(0, wells.Length - 1);
                    }
                    if (!string.IsNullOrEmpty(wells))
                    {
                        x.SelectSingleNode("residueValidWells").InnerText = wells;
                    }
                    else
                    {
                        x.SelectSingleNode("residueValidWells").InnerText = "";
                    }

                    foreach (var lb in labwareList)
                    {
                        int row = lb.row;
                        int col = lb.col;
                        //int pos = col * Shared.SoftwareInformation.rows + row;
                        //Canvas canvas = gridTable.Children[pos] as Canvas;

                        // 获取台面对应格子的Canvas
                        Canvas canvas = null;
                        TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();
                        if (tabletopTemplate == null)
                        {
                            canvas = GetGridTableCanvas(row, col);
                        }
                        else
                        {
                            canvas = GetCanvasByLatticeNumOfLabware(lb);
                        }

                        if (canvas == null)
                        {
                            continue;
                        }

                        ControlLabware control = Utilities.FindVisualChild<ControlLabware>(canvas);
                        if (lb.label.Equals(tipsTable.lattice_num))
                        {
                            control.ValidWells = wells;
                            //control.InValidWells = "";
                        }
                    }
                }
            }
        }
        #endregion

        #region 夹爪移动动画
        #region 根据抓板转移执行动作的板位，创建两个台面之间的动画耗材转移，仅支持正规耗材板位
        Canvas pathCanvas = new Canvas();
        ControlLabware pickLabware;//抓板位上的耗材对象
        List<ControlLabware> pickLabwareList;//抓板位上的耗材对象集
        Canvas pickCanvas;//抓板位对象
        Canvas placeCanvas;//放板位对象
        Stack<LabwareEx> moveLabwareExes;//保存被移动的耗材的DataContext
        public void GenerateAnimation(XmlNode xmlEnv,MethodGripTransport gripTransportData)
        {
            string sourceLatticeName, targetLatticeName;
            sourceLatticeName = gripTransportData.srcPositionText;
            targetLatticeName = gripTransportData.desPositionText;
            moveLabwareExes = new Stack<LabwareEx>();

            System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
            {
                Canvas srcCanvas = pickCanvas = this.GetGridTableCanvasByNum(sourceLatticeName);
                if (srcCanvas != null)
                {
                    pickLabwareList = Utilities.FindAllVisualChild<ControlLabware>(srcCanvas);//叠放的耗材
                    if (gripTransportData.transportMode == (int)GripTransportModeEnum.TransportAll)
                    {
                        
                    }
                    else if (gripTransportData.transportMode == (int)GripTransportModeEnum.TransportExceptOne)
                    {
                        pickLabwareList.RemoveAt(0);
                    }
                    else if (gripTransportData.transportMode == (int)GripTransportModeEnum.TransportCount)
                    {
                        int countOfLeftLabware = pickLabwareList.Count - gripTransportData.transportCount;
                        for (int i = 0; i < countOfLeftLabware; i++)
                        {
                            pickLabwareList.RemoveAt(0);
                        }
                    }

                    pickLabware = Utilities.FindVisualChild<ControlLabware>(srcCanvas);//叠放的耗材怎么搜索？
                    pickLabwareList.Reverse();
                    foreach (ControlLabware c in pickLabwareList)
                    {
                        Stack<LabwareEx> labwareExes = new Stack<LabwareEx>();
                        labwareExes = (Stack<LabwareEx>)srcCanvas.Tag;
                        LabwareEx labwareExPop = new LabwareEx(); ;
                        if (labwareExes.Count > 0)
                        {
                            moveLabwareExes.Push(labwareExes.Pop());
                        }
                        srcCanvas.Children.Remove(c);
                    }
                    //srcCanvas.DataContext = null;                                             
                    
                    System.Windows.Shapes.Path pathT = new System.Windows.Shapes.Path();
                    pathT.StrokeThickness = 1;
                    pathT.Stroke = Brushes.Transparent;
                    //pathT.Width = gridTable.ActualWidth;
                    //pathT.Height= gridTable.ActualHeight;

                    pathCanvas = new Canvas();
                    pathCanvas.Background = Brushes.Transparent;
                    pathCanvas.Width = gridTable.ActualWidth;
                    pathCanvas.Height = gridTable.ActualHeight;
                    Canvas.SetZIndex(pathCanvas, 999);
                    pathCanvas.Children.Add(pathT);

                    //根据重叠的层级，设置margin，用的是下层的耗材数据计算
                    double leftMargin = 0;//离左侧距离
                    double bottomMargin = 0;//离底部距离
                    pickLabwareList.Reverse();
                    for (int i = 0; i < pickLabwareList.Count; i++)
                    {
                        if(i==0)
                        {

                        }
                        else if (i != 0)
                        {
                            leftMargin += pickLabwareList[i].LabwareDeep;
                            bottomMargin += pickLabwareList[i].LabwareDeep;
                        }
                        pickLabwareList[i].Margin = new Thickness(leftMargin, 0, 0, bottomMargin);
                        pathCanvas.Children.Add(pickLabwareList[i]);
                    }

                    gridTable.Children.Add(pathCanvas);
                    Grid.SetColumnSpan(pathT, 5);
                    Grid.SetRowSpan(pathT, 5);
                    Grid.SetColumn(pathCanvas, 0);
                    Grid.SetRow(pathCanvas, 0);
                    //Grid.SetColumnSpan(pathCanvas, 5);
                    //Grid.SetRowSpan(pathCanvas, 5);

                    string startMovePoint = GetStraightLineStartPointAXis(Grid.GetRow(srcCanvas), Grid.GetColumn(srcCanvas));

                    //目标
                    placeCanvas = this.GetGridTableCanvasByNum(targetLatticeName);
                    string endMovePoint = GetStraightLineStartPointAXis(Grid.GetRow(placeCanvas), Grid.GetColumn(placeCanvas));

                    pathT.Data = Geometry.Parse("M " + startMovePoint + " L " + endMovePoint);
                    Console.WriteLine("M " + startMovePoint + " L " + endMovePoint);
                    ExcuteAnimation(pickLabwareList, pathT, Convert.ToInt32(ConfigurationManager.AppSettings["AnimationDurationMilliSeconds"]));


                }
            }));
        }
        #endregion

        #region 计算动画移动路径坐标
        private string GetStraightLineStartPointAXis(int i, int j)
        {
            System.Windows.Point gridLocation = gridTable.TransformToAncestor(this).Transform(new System.Windows.Point(0, 0));
            string endMovePoint = string.Empty;
            if (i == 0 && j == 0)
            {
                endMovePoint = (gridTable.ColumnDefinitions[i].ActualWidth / 2).ToString() + "," + (gridTable.RowDefinitions[j].ActualHeight / 2).ToString();
            }
            else if (i > 0 && j > 0)
            {
                endMovePoint = (gridTable.ColumnDefinitions[i].ActualWidth * j + gridTable.ColumnDefinitions[i].ActualWidth / 2).ToString() + "," + (gridTable.RowDefinitions[j].ActualHeight * i + gridTable.RowDefinitions[j].ActualHeight / 2).ToString();
            }
            else if (i > 0 && j == 0)
            {
                endMovePoint = (gridTable.ColumnDefinitions[i].ActualWidth / 2).ToString() + "," + (gridTable.RowDefinitions[4].ActualHeight * i + gridTable.RowDefinitions[j].ActualHeight / 2).ToString();
            }
            else if (i == 0 && j > 0)
            {
                endMovePoint = (gridTable.ColumnDefinitions[i].ActualWidth * j + gridTable.ColumnDefinitions[i].ActualWidth / 2).ToString() + "," + (gridTable.RowDefinitions[j].ActualHeight / 2).ToString();
            }
            //path1.Data = Geometry.Parse("M " + startMovePoint + " L " + endMovePoint);
            return endMovePoint;
        }
        #endregion

        #region 按路径执行耗材移动动画
        /// <summary>
        /// 使用动画前提：先获取原板位上耗材
        /// 调用该函数
        /// 函数执行结束后，添加耗材到新板位上
        /// </summary>
        /// <param name="controlLabware">要移动的耗材对象</param>
        /// <param name="pathT"></param>
        /// <param name="durationMilliSeconds"></param>
        public void ExcuteAnimation(List<ControlLabware> controlLabwareList,System.Windows.Shapes.Path pathT,int durationMilliSeconds)
        {
            //需要根据行列设置偏移
            double topValue=0, leftValue=0;
            //topValue = gridTable.RowDefinitions[j].ActualHeight * i;
            //leftValue = gridTable.ColumnDefinitions[i].ActualWidth * j;
            Canvas canvas = gridTable.Children[0] as Canvas;

            TranslateTransform translate = new TranslateTransform();
            double topMargin=0, leftMargin = 0;
            int count = 0;
            foreach (ControlLabware c in controlLabwareList)
            {
                Canvas.SetTop(c, -canvas.ActualHeight / 2 - topValue-topMargin-c.LabwareDeep);
                Canvas.SetLeft(c, -canvas.ActualWidth / 2 - leftValue);
                c.RenderTransformOrigin = new System.Windows.Point(0.5, 0.5);
                c.RenderTransform = translate;
                leftMargin += c.LabwareDeep;
                topMargin += c.LabwareDeep;
            }

            NameScope.SetNameScope(this, new NameScope());
            this.RegisterName("translate", translate);

            DoubleAnimationUsingPath animationX = new DoubleAnimationUsingPath();
            animationX.PathGeometry = pathT.Data.GetFlattenedPathGeometry();
            animationX.Source = PathAnimationSource.X;
            animationX.Duration = new Duration(TimeSpan.FromMilliseconds(durationMilliSeconds));

            DoubleAnimationUsingPath animationY = new DoubleAnimationUsingPath();
            animationY.PathGeometry = pathT.Data.GetFlattenedPathGeometry();
            animationY.Source = PathAnimationSource.Y;
            animationY.Duration = animationX.Duration;

            
            Storyboard story = new Storyboard();
            //story.RepeatBehavior = RepeatBehavior.Forever;
            //story.AutoReverse = true;
            story.Children.Add(animationX);
            story.Children.Add(animationY);
            Storyboard.SetTargetName(animationX, "translate");
            Storyboard.SetTargetName(animationY, "translate");
            Storyboard.SetTargetProperty(animationX, new PropertyPath(TranslateTransform.XProperty));
            Storyboard.SetTargetProperty(animationY, new PropertyPath(TranslateTransform.YProperty));
  
            //Storyboard.SetTarget(animationX, gridTable);
            //Storyboard.SetTargetProperty(animationX, new PropertyPath("Opacity"));
            //Storyboard.SetTarget(animationY, gridTable);
            //Storyboard.SetTargetProperty(animationY, new PropertyPath("Opacity"));

            // 注册Completed事件
            story.Completed += Storyboard_Completed;
            story.Begin(this);
        }
        #endregion

        // 动画完成时调用的事件处理器
        Stack<LabwareEx> labwareExes = new Stack<LabwareEx>();
        private void Storyboard_Completed(object sender, EventArgs e)
        {
            // 动画执行完毕后的代码
            //MessageBox.Show("Storyboard 执行完毕！");
            //移除pathT和pathCanvas
            foreach (ControlLabware c in pickLabwareList)
            {
                pathCanvas.Children.Remove(c);
            }
            gridTable.Children.Remove(pathCanvas);

            List<ControlLabware> placeLabware = Utilities.FindAllVisualChild<ControlLabware>(placeCanvas);
            if(placeLabware!=null)//叠放
            {
                //placeCanvas.DataContext = null;
                //placeCanvas.Children.Remove(placeLabware);
            }

            //placeCanvas = this.GetGridTableCanvasByNum("P13");
            //placeCanvas.Background = Brushes.Red;
            //Canvas.SetLeft(pickLabware, 0);
            //Canvas.SetTop(pickLabware, 0);
            foreach (ControlLabware c in pickLabwareList)
            {
                
                LabwareEx lb = moveLabwareExes.Pop();
                pickLabware = c;
                lb.label = placeCanvas.Name;
                ControlLabware control = new ControlLabware();
                control.LeftSideColor = pickLabware.LeftSideColor;
                control.FrontColor = pickLabware.FrontColor;
                control.TopColor = pickLabware.TopColor;
                control.BorderColor = pickLabware.BorderColor;

                if (pickLabware.LabwareType.ToString() == EnumManagement.GetEnumValue(ConsumableTypeEnum.CircularDish).ToString())      // 圆形皿
                {
                    control.LabwareWidth = placeCanvas.ActualWidth;
                    control.LabwareHeight = placeCanvas.ActualHeight;// canvas.ActualWidth*50/90;
                    control.Rows = pickLabware.Rows;
                    control.Columns = pickLabware.Columns;
                    control.WellColor = Colors.White;
                    control.IsFill = true;
                    control.Label = placeCanvas.Name;
                    control.LabwareName = pickLabware.LabwareName;
                    control.LabwareType = Convert.ToInt16(pickLabware.LabwareType);
                    control.ValidWells = pickLabware.ValidWells;
                    control.Width = placeCanvas.ActualWidth;
                    control.Height = placeCanvas.ActualHeight + 4;
                }
                else if (pickLabware.LabwareType.ToString() == EnumManagement.GetEnumValue(ConsumableTypeEnum.TipsBox).ToString())      // 吸头盒
                {
                    control.LabwareWidth = placeCanvas.ActualWidth;
                    control.LabwareHeight = placeCanvas.ActualHeight;
                    control.Rows = (int)pickLabware.Rows;
                    control.Columns = (int)pickLabware.Columns;
                    control.WellColor = Colors.White;
                    control.IsFill = true;
                    control.Label = placeCanvas.Name;
                    control.LabwareName = pickLabware.LabwareName;
                    control.LabwareType = Convert.ToInt16(pickLabware.LabwareType);
                }
                else
                {
                    control.LabwareWidth = placeCanvas.ActualWidth;
                    control.LabwareHeight = placeCanvas.ActualHeight;
                    control.Rows = (int)pickLabware.Rows;
                    control.Columns = (int)pickLabware.Columns;
                    control.WellColor = Colors.White;
                    control.IsFill = true;
                    control.Label = placeCanvas.Name;
                    control.LabwareName = pickLabware.LabwareName;
                    control.LabwareType = Convert.ToInt16(pickLabware.LabwareType);
                    control.ValidWells = pickLabware.ValidWells;
                }

                if (pickLabware.LabwareType.ToString() == EnumManagement.GetEnumValue(ConsumableTypeEnum.TipsBox).ToString() ||
                    pickLabware.LabwareType.ToString() == EnumManagement.GetEnumValue(ConsumableTypeEnum.Plate).ToString())         // 吸头盒、孔板
                {
                    // 设置有效孔位
                    string validWells = ComUtility.GetValidWells((int)pickLabware.Rows, (int)pickLabware.Columns);
                    pickLabware.ValidWells = control.ValidWells = validWells;
                }
                else
                {
                    control.LabwareWidth = placeCanvas.ActualWidth;
                    control.LabwareHeight = placeCanvas.ActualHeight;
                    control.Rows = (int)pickLabware.Rows;
                    control.Columns = (int)pickLabware.Columns;
                    control.WellColor = Colors.White;
                    control.IsFill = true;
                    control.Label = placeCanvas.Name;
                    control.LabwareName = pickLabware.LabwareName;
                    control.LabwareType = Convert.ToInt16(pickLabware.LabwareType);
                    control.ValidWells = pickLabware.ValidWells;
                }

                Canvas.SetLeft(control, 0);
                Canvas.SetBottom(control, 0);
                pickLabware.Rows = Grid.GetRow(placeCanvas);
                pickLabware.Columns = Grid.GetColumn(placeCanvas);
                lb.position = placeCanvas.Name;
                placeCanvas.DataContext = lb;

                labwareExes = (Stack<LabwareEx>)placeCanvas.Tag;
                if (labwareExes != null)
                {
                }
                else
                {
                    labwareExes = new Stack<LabwareEx>();
                }
                labwareExes.Push(lb);
                placeCanvas.Tag = labwareExes;
                //根据重叠的层级，设置margin，用的是下层的耗材数据计算
                double leftMargin = 0;//离左侧距离
                double bottomMargin = 0;//离底部距离
                for (int i = 0; i < placeCanvas.Children.Count; i++)
                {
                    ControlLabware a = placeCanvas.Children[i] as ControlLabware;
                    if (a != null)
                    {
                        leftMargin += a.LabwareDeep;
                        bottomMargin += a.LabwareDeep;
                    }
                }

                control.Margin = new Thickness(leftMargin, 0, 0, bottomMargin);
                placeCanvas.Children.Add(control);
                //如果是第二及其以上耗材，要隐藏标签
                if (labwareExes.Count > 1)
                {
                    control.Label = "";
                }
                else
                {
                    control.Label = placeCanvas.Name;
                }
            }
        }
        #endregion

        #region 暂停弹出倒计时或者提示信息界面
        public bool ShowDialogForPause(MethodPauseMove methodPauseMove)
        {
            bool result = false;
            if (!isRemotingOper)
            {
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    if (methodPauseMove.pauseMode == 0)
                    {
                        //调用倒计时界面
                        PlsPausewin plsPausewin = new PlsPausewin(methodPauseMove);
                        plsPausewin.Height = this.ActualHeight;
                        plsPausewin.Width = this.ActualWidth;
                        plsPausewin.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                        SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(40, 0, 0, 0));
                        plsPausewin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                        result = (bool)plsPausewin.ShowDialog();
                    }
                    else
                    {
                        PlsToolTipWin plsPausewin = new PlsToolTipWin(methodPauseMove.pauseTipInfo);
                        plsPausewin.Height = this.ActualHeight;
                        plsPausewin.Width = this.ActualWidth;
                        plsPausewin.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                        SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(70, 0, 0, 0));
                        plsPausewin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                        result = (bool)plsPausewin.ShowDialog();
                    }
                }));
            }
            else
            {
                if (methodPauseMove.pauseMode == 0)
                {
                    // 调用倒计时界面
                    PlsPausewin plsPausewin = new PlsPausewin(methodPauseMove);
                    plsPausewin.Height = this.ActualHeight;
                    plsPausewin.Width = this.ActualWidth;
                    plsPausewin.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                    SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(40, 0, 0, 0));
                    plsPausewin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                    result = (bool)plsPausewin.ShowDialog();
                }
                else
                {
                    PlsToolTipWin plsPausewin = new PlsToolTipWin(methodPauseMove.pauseTipInfo);
                    plsPausewin.Height = this.ActualHeight;
                    plsPausewin.Width = this.ActualWidth;
                    plsPausewin.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                    SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(70, 0, 0, 0));
                    plsPausewin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                    result = (bool)plsPausewin.ShowDialog();
                }
            }

            return result;
        }
        #endregion

        #region 暂停弹出等待倒计时界面
        public bool ShowDialogForWaitFor(MethodTimer methodTimer,MethodWaitFor methodWaitFor)
        {
            bool result = false;
            if (!isRemotingOper)
            {
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    //调用倒计时界面
                    PlsWaitForwin plsWaitForwin = new PlsWaitForwin(methodTimer, methodWaitFor);
                    plsWaitForwin.Height = this.ActualHeight;
                    plsWaitForwin.Width = this.ActualWidth;
                    plsWaitForwin.WindowStartupLocation = WindowStartupLocation.CenterScreen;

                    SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(40, 0, 0, 0));
                    plsWaitForwin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                    result = (bool)plsWaitForwin.ShowDialog();
                }));
            }
            else
            {
                // 调用倒计时界面
                PlsWaitForwin plsWaitForwin = new PlsWaitForwin(methodTimer, methodWaitFor);
                plsWaitForwin.Height = this.ActualHeight;
                plsWaitForwin.Width = this.ActualWidth;
                plsWaitForwin.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(40, 0, 0, 0));
                plsWaitForwin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                result = (bool)plsWaitForwin.ShowDialog();
            }

            return result;
        }
        #endregion

        #region 添加吸液数据行进入报表
        public void addDataIntoReport(string labwareLabel, string volumn, string[] strWell, string result, string strBarcode = "", string[] indexCoating = null)
        {
            DataExportBll dataExportBll = new DataExportBll();
            try
            {
                List<DropdownName> dropdownNames = dataExportBll.GenerateReportColumn();

                for (int i = 0; i < strWell.Length; i++)
                {
                    int maxStepIndex = 0;
                    if (isRemotingOper)
                    {
                        maxStepIndex = ExperimentRunDetailDB.GetMaxStepIndexByRunChoiceBacteraId(ControlCom.ExpChoiceBactera(true, currentExperimentRunLog.experimentrunid).RunChoiceBacteraId) + 1;
                    }
                    else
                    {
                        maxStepIndex = ExperimentRunDetailDB.GetMaxStepIndexByRunChoiceBacteraId(ControlCom.ExpChoiceBactera().RunChoiceBacteraId) + 1;
                    }
                    DataRow dataRow = dataTableTotal.NewRow();
                    if (indexCoating != null)
                    {
                        dataRow[dropdownNames[0].dropdown_name] = indexCoating[i];
                    }
                    dataRow[dropdownNames[1].dropdown_name] = labwareLabel;
                    dataRow[dropdownNames[2].dropdown_name] = strBarcode;
                    dataRow[dropdownNames[3].dropdown_name] = strWell[i];
                    dataRow[dropdownNames[7].dropdown_name] = volumn;
                    dataRow[dropdownNames[8].dropdown_name] = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff");
                    dataRow[dropdownNames[10].dropdown_name] = result;
                    dataRow["StepIndex"] = maxStepIndex.ToString();
                    dataTableTotal.Rows.Add(dataRow);

                    #region 记录到数据库
                    ExperimentRunDetailModel experimentRunDetail = new ExperimentRunDetailModel();
                    if (isRemotingOper)
                    {
                        experimentRunDetail.RunChoiceBacteraId = ControlCom.ExpChoiceBactera().RunChoiceBacteraId;
                        experimentRunDetail.StepIndex = maxStepIndex;
                        experimentRunDetail.ExperimentId = currentExperimentRunLog.experimentrunid;
                    }
                    else
                    {
                        experimentRunDetail.RunChoiceBacteraId = ControlCom.ExpChoiceBactera().RunChoiceBacteraId;
                        experimentRunDetail.StepIndex = maxStepIndex;
                        experimentRunDetail.ExperimentId = Shared.Exp.ExperimentId;
                    }
                    experimentRunDetail.ExecuteMethod = "Aspirate";
                    experimentRunDetail.SourcePosition = labwareLabel;
                    experimentRunDetail.SourceBarcode = strBarcode;
                    experimentRunDetail.SourceWell = strWell[i];
                    experimentRunDetail.Volume = Convert.ToDouble(volumn);
                    experimentRunDetail.SourceStartTime = DateTime.Now;
                    experimentRunDetail.SourceEndTime = DateTime.Now;
                    experimentRunDetail.ExecSourceResult = result.Equals("pass") ? 1 : 0;
                    ExperimentRunDetailDB.Add(experimentRunDetail);
                    #endregion
                }
            }
            catch (Exception ex)
            {

                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 添加吸液数据行进入报表
        /// <summary>
        /// 添加吸液数据行进入报表
        /// </summary>
        /// <param name="labwareLabel"></param>
        /// <param name="volumn"></param>
        /// <param name="strWell"></param>
        /// <param name="result">多个结果</param>
        /// <param name="strBarcode"></param>
        /// <param name="indexCoating"></param>
        public void addDataIntoReport(string labwareLabel, string volumn, string[] strWell, string[] result, string strBarcode = "", string[] indexCoating = null)
        {
            DataExportBll dataExportBll = new DataExportBll();
            try
            {
                List<DropdownName> dropdownNames = dataExportBll.GenerateReportColumn();

                for (int i = 0; i < strWell.Length; i++)
                {
                    int maxStepIndex = 0;
                    if (isRemotingOper)
                    {
                        maxStepIndex = ExperimentRunDetailDB.GetMaxStepIndexByRunChoiceBacteraId(ControlCom.ExpChoiceBactera(true, currentExperimentRunLog.experimentrunid).RunChoiceBacteraId) + 1;
                    }
                    else
                    {
                        maxStepIndex = ExperimentRunDetailDB.GetMaxStepIndexByRunChoiceBacteraId(ControlCom.ExpChoiceBactera().RunChoiceBacteraId) + 1;
                    }
                    DataRow dataRow = dataTableTotal.NewRow();
                    if (indexCoating != null)
                    {
                        dataRow[dropdownNames[0].dropdown_name] = indexCoating[i];
                    }
                    dataRow[dropdownNames[1].dropdown_name] = labwareLabel;
                    dataRow[dropdownNames[2].dropdown_name] = strBarcode;
                    dataRow[dropdownNames[3].dropdown_name] = strWell[i];
                    dataRow[dropdownNames[7].dropdown_name] = volumn;
                    dataRow[dropdownNames[8].dropdown_name] = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff");
                    dataRow[dropdownNames[10].dropdown_name] = result[i];
                    dataRow["StepIndex"] = maxStepIndex.ToString();
                    dataTableTotal.Rows.Add(dataRow);

                    #region 记录到数据库
                    ExperimentRunDetailModel experimentRunDetail = new ExperimentRunDetailModel();
                    if (isRemotingOper)
                    {
                        experimentRunDetail.RunChoiceBacteraId = ControlCom.ExpChoiceBactera().RunChoiceBacteraId;
                        experimentRunDetail.StepIndex = maxStepIndex;
                        experimentRunDetail.ExperimentId = currentExperimentRunLog.experimentrunid;
                    }
                    else
                    {
                        experimentRunDetail.RunChoiceBacteraId = ControlCom.ExpChoiceBactera().RunChoiceBacteraId;
                        experimentRunDetail.StepIndex = maxStepIndex;
                        experimentRunDetail.ExperimentId = Shared.Exp.ExperimentId;
                    }
                    experimentRunDetail.ExecuteMethod = "Aspirate";
                    experimentRunDetail.SourcePosition = labwareLabel;
                    experimentRunDetail.SourceBarcode = strBarcode;
                    experimentRunDetail.SourceWell = strWell[i];
                    experimentRunDetail.Volume = Convert.ToDouble(volumn);
                    experimentRunDetail.SourceStartTime = DateTime.Now;
                    experimentRunDetail.SourceEndTime = DateTime.Now;
                    experimentRunDetail.ExecSourceResult = result[i].Equals("pass") ? 1 : 0;
                    ExperimentRunDetailDB.Add(experimentRunDetail);
                    #endregion
                }
            }
            catch (Exception ex)
            {

                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 添加挑菌数据行进入报表
        public void addChoiceDataIntoReport(TipsTable tipsTable, string labwareLabel, string volumn, string[] strWell, string result, string indexCoating,
            DateTime startTime, DateTime endTime, string actionName, string strBarcode = "")
        {
            CoatingReportBll dataExportBll = new CoatingReportBll();
            try
            {
                List<DropdownName> dropdownNames = dataExportBll.GenerateReportColumn();

                for (int i = 0; i < strWell.Length; i++)
                {
                    DataRow dataRow = dataTableTotal.NewRow();
                    if (!string.IsNullOrEmpty(indexCoating))
                    {
                        dataRow[dropdownNames[0].dropdown_name] = indexCoating;
                    }
                    else
                    {
                        dataRow[dropdownNames[0].dropdown_name] = dataTableTotal.Rows.Count + 1;
                    }

                    int maxStepIndex = ExperimentRunDetailDB.GetMaxStepIndexByRunChoiceBacteraId(ControlCom.ExpChoiceBactera().RunChoiceBacteraId) + 1;

                    dataRow[dropdownNames[1].dropdown_name] = labwareLabel;
                    dataRow[dropdownNames[2].dropdown_name] = strBarcode;
                    dataRow[dropdownNames[3].dropdown_name] = strWell[i];
                    dataRow[dropdownNames[7].dropdown_name] = volumn;
                    dataRow[dropdownNames[8].dropdown_name] = startTime.ToString("yyyy-MM-dd HH:mm:ss:fff");
                    dataRow[dropdownNames[10].dropdown_name] = result;
                    dataRow["StepIndex"] = maxStepIndex.ToString();
                    dataTableTotal.Rows.Add(dataRow);

                    #region 记录到数据库
                    ExperimentRunDetailModel experimentRunDetail = new ExperimentRunDetailModel();
                    experimentRunDetail.RunChoiceBacteraId = ControlCom.ExpChoiceBactera().RunChoiceBacteraId;
                    experimentRunDetail.StepIndex = maxStepIndex;
                    experimentRunDetail.ExperimentId = Shared.Exp.ExperimentId;
                    experimentRunDetail.ExecuteMethod = actionName;
                    experimentRunDetail.SourcePosition = dataRow[dropdownNames[1].dropdown_name].ToString();
                    experimentRunDetail.SourceBarcode = dataRow[dropdownNames[2].dropdown_name].ToString();
                    experimentRunDetail.SourceWell = strWell[i];
                    experimentRunDetail.Volume = Convert.ToDouble(dataRow[dropdownNames[7].dropdown_name]);
                    experimentRunDetail.SourceStartTime = startTime;
                    experimentRunDetail.SourceEndTime = endTime;
                    experimentRunDetail.ExecSourceResult = (dataRow[dropdownNames[10].dropdown_name].ToString().Equals("pass") || dataRow[dropdownNames[10].dropdown_name].ToString().Equals("1")) ? 1 : 0;
                    ExperimentRunDetailDB.Add(experimentRunDetail);
                    #endregion
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 添加排液数据行进入报表
        public void addFinishDataIntoReport(TipsTable tipsTable, string labwareLabel, string volumn, string[] strWell,
            string result, string[] strBarcode, int atimeTotal = 0, int cnTotal = 0)
        {
            DataExportBll dataExportBll = new DataExportBll();
            try
            {
                List<DropdownName> dropdownNames = dataExportBll.GenerateReportColumn();

                for (int i = 0; i < strWell.Length; i++)
                {
                    DataRow dataRow = dataTableTotal.Rows[dataTableTotal.Rows.Count - strWell.Length + i];
                    if (atimeTotal != 0)
                    {
                        dataRow = dataTableTotal.Rows[dataTableTotal.Rows.Count - atimeTotal + (cnTotal - strWell.Length) + i];
                    }

                    if (string.IsNullOrEmpty(dataRow[dropdownNames[4].dropdown_name].ToString()))
                    {
                        dataRow[dropdownNames[4].dropdown_name] = labwareLabel;
                        dataRow[dropdownNames[5].dropdown_name] = strBarcode[i] == "" ? "" : strBarcode[i].ToString();
                        dataRow[dropdownNames[6].dropdown_name] = strWell[i];
                        dataRow[dropdownNames[7].dropdown_name] = volumn;
                        dataRow[dropdownNames[9].dropdown_name] = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff");
                        dataRow[dropdownNames[10].dropdown_name] = result;

                        // 更新到数据库
                        int nStepIndex = Convert.ToInt32(dataRow["StepIndex"].ToString());
                        ExperimentRunDetailModel experimentRunDetail = ExperimentRunDetailDB.GetInfodById(ControlCom.ExpChoiceBactera().RunChoiceBacteraId, nStepIndex);
                        experimentRunDetail.TargetPosition = labwareLabel;
                        experimentRunDetail.TargetBarcode = strBarcode[i] == "" ? "" : strBarcode[i].ToString();
                        experimentRunDetail.TargetWell = strWell[i];
                        experimentRunDetail.ActionName = "Dispense";
                        experimentRunDetail.TargetStartTime = DateTime.Now;
                        experimentRunDetail.TargetEndTime = DateTime.Now;
                        experimentRunDetail.ExecTargetResult = result.Equals("pass") ? 1 : 0;
                        ExperimentRunDetailDB.Update(experimentRunDetail);
                    }
                    else
                    {
                        if (i == 0)
                        {
                            // 分液状态下要增加吸液排液记录
                            for (int j = 0; j < strWell.Length; j++)
                            {
                                DataRow dr = dataTableTotal.NewRow();
                                dr[dropdownNames[0].dropdown_name] = dataRow[dropdownNames[0].dropdown_name];
                                dr[dropdownNames[1].dropdown_name] = dataRow[dropdownNames[4].dropdown_name];
                                dr[dropdownNames[2].dropdown_name] = dataRow[dropdownNames[5].dropdown_name];
                                dr[dropdownNames[3].dropdown_name] = strWell[j];//dataRow[dropdownNames[5].dropdown_name];
                                dr[dropdownNames[7].dropdown_name] = dataRow[dropdownNames[7].dropdown_name];
                                dr[dropdownNames[8].dropdown_name] = dataRow[dropdownNames[9].dropdown_name];
                                dr[dropdownNames[10].dropdown_name] = dataRow[dropdownNames[10].dropdown_name];

                                dataTableTotal.Rows.Add(dr);

                                // 添加
                                int maxStepIndex = ExperimentRunDetailDB.GetMaxStepIndexByRunChoiceBacteraId(ControlCom.ExpChoiceBactera().RunChoiceBacteraId) + 1;

                                ExperimentRunDetailModel experimentRunDetail = new ExperimentRunDetailModel();
                                experimentRunDetail.RunChoiceBacteraId = ControlCom.ExpChoiceBactera().RunChoiceBacteraId;
                                experimentRunDetail.ExperimentId = Shared.Exp.ExperimentId;
                                experimentRunDetail.StepIndex = maxStepIndex;
                                experimentRunDetail.ExecuteMethod = "Aspirate";
                                experimentRunDetail.SourcePosition = dataRow[dropdownNames[4].dropdown_name].ToString();
                                experimentRunDetail.SourceBarcode = dataRow[dropdownNames[5].dropdown_name].ToString();
                                experimentRunDetail.SourceWell = strWell[i];
                                experimentRunDetail.Volume = Convert.ToDouble(dataRow[dropdownNames[7].dropdown_name]);
                                experimentRunDetail.SourceStartTime = DateTime.Now;
                                experimentRunDetail.SourceEndTime = DateTime.Now;
                                experimentRunDetail.ExecSourceResult = dataRow[dropdownNames[10].dropdown_name].ToString().Equals("pass") ? 1 : 0;
                                ExperimentRunDetailDB.Add(experimentRunDetail);
                            }

                            DataRow d = dataTableTotal.Rows[dataTableTotal.Rows.Count - strWell.Length + i];
                            if (atimeTotal != 0)
                            {
                                d = dataTableTotal.Rows[dataTableTotal.Rows.Count - atimeTotal + (cnTotal - strWell.Length) + i];
                            }
                            if (string.IsNullOrEmpty(d[dropdownNames[4].dropdown_name].ToString()))
                            {
                                d[dropdownNames[5].dropdown_name] = strBarcode[i] == "" ? "" : strBarcode[i].ToString();
                                d[dropdownNames[6].dropdown_name] = strWell[i];
                                d[dropdownNames[7].dropdown_name] = volumn;
                                d[dropdownNames[9].dropdown_name] = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff");
                                d[dropdownNames[10].dropdown_name] = result;

                                // 更新
                                int nStepIndex = Convert.ToInt32(d["StepIndex"].ToString());
                                ExperimentRunDetailModel experimentRunDetail = ExperimentRunDetailDB.GetInfodById(ControlCom.ExpChoiceBactera().RunChoiceBacteraId, nStepIndex);
                                experimentRunDetail.TargetPosition = labwareLabel;
                                experimentRunDetail.TargetBarcode = strBarcode[i] == "" ? "" : strBarcode[i].ToString();
                                experimentRunDetail.TargetWell = strWell[i];
                                experimentRunDetail.ActionName = "Dispense";
                                experimentRunDetail.TargetStartTime = DateTime.Now;
                                experimentRunDetail.TargetEndTime = DateTime.Now;
                                experimentRunDetail.ExecTargetResult = result.Equals("pass") ? 1 : 0;
                                ExperimentRunDetailDB.Update(experimentRunDetail);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 添加涂布数据行进入报表
        public void addCoatingFinishDataIntoReport(TipsTable tipsTable, string labwareLabel, string volumn, string[] strWell, string result,
            string[] indexCoating, string strBarcode, DateTime startTime, DateTime endTime, string actionName, int index = 0, int loop = 0)
        {
            CoatingReportBll dataExportBll = new CoatingReportBll();
            try
            {
                List<DropdownName> dropdownNames = dataExportBll.GenerateReportColumn();
                int currentDataCount = dataTableTotal.Rows.Count;
                int countOfValid = 0;//本次有效的通道号个数

                for (int i = 0; i < strWell.Length; i++)
                {
                    {
                        if (strWell[i] == null || strWell[i] == "")
                        {
                            break;
                        }
                        DataRow dataRow = dataTableTotal.Rows[dataTableTotal.Rows.Count - index + i];
                        if (string.IsNullOrEmpty(dataRow[dropdownNames[4].dropdown_name].ToString()))
                        {
                            dataRow[dropdownNames[4].dropdown_name] = labwareLabel;
                            dataRow[dropdownNames[5].dropdown_name] = strBarcode;
                            dataRow[dropdownNames[6].dropdown_name] = strWell[i];
                            dataRow[dropdownNames[7].dropdown_name] = volumn;
                            dataRow[dropdownNames[9].dropdown_name] = startTime.ToString("yyyy-MM-dd HH:mm:ss:fff");
                            dataRow[dropdownNames[10].dropdown_name] = result;

                            // 更新到数据库
                            int nStepIndex = Convert.ToInt32(dataRow["StepIndex"].ToString());
                            ExperimentRunDetailModel experimentRunDetail = ExperimentRunDetailDB.GetInfodById(ControlCom.ExpChoiceBactera().RunChoiceBacteraId, nStepIndex);
                            experimentRunDetail.TargetPosition = labwareLabel;
                            experimentRunDetail.TargetBarcode = strBarcode;
                            experimentRunDetail.TargetWell = strWell[i];
                            experimentRunDetail.Volume = Convert.ToDouble(dataRow[dropdownNames[7].dropdown_name]);
                            experimentRunDetail.ActionName = actionName;
                            experimentRunDetail.TargetStartTime = startTime;
                            experimentRunDetail.TargetEndTime = endTime;
                            experimentRunDetail.ExecTargetResult = (result.Equals("pass") || result.Equals("1")) ? 1 : 0;
                            ExperimentRunDetailDB.Update(experimentRunDetail);
                        }
                        else
                        {
                            if (loop == 0)
                            {
                                dataRow = dataTableTotal.Rows[currentDataCount - index + i];
                            }
                            if (loop == 1)
                            {
                                dataRow = dataTableTotal.Rows[currentDataCount - index + i - 2];
                            }
                            if (loop == 2)
                            {
                                dataRow = dataTableTotal.Rows[currentDataCount - index + i - 4];
                            }

                            if (i == 0)
                            {
                                //复制状态下要增加涂布记录
                                for (int j = 0; j < strWell.Length; j++)
                                {
                                    if (strWell[j] == null || strWell[j] == "")
                                    {
                                        break;
                                    }
                                    countOfValid++;
                                    DataRow dr = dataTableTotal.NewRow();
                                    if (isRemotingOper)
                                    {
                                        dr[dropdownNames[0].dropdown_name] = indexCoating[j];
                                    }
                                    else
                                    {
                                        dr[dropdownNames[0].dropdown_name] = dataTableTotal.Rows.Count + 1;
                                    }

                                    dr[dropdownNames[1].dropdown_name] = dataRow[dropdownNames[4].dropdown_name];
                                    dr[dropdownNames[2].dropdown_name] = dataRow[dropdownNames[5].dropdown_name];
                                    dr[dropdownNames[3].dropdown_name] = strWell[j];//dataRow[dropdownNames[5].dropdown_name];
                                    dr[dropdownNames[7].dropdown_name] = dataRow[dropdownNames[7].dropdown_name];
                                    dr[dropdownNames[8].dropdown_name] = dataRow[dropdownNames[9].dropdown_name];
                                    dr[dropdownNames[10].dropdown_name] = dataRow[dropdownNames[10].dropdown_name];
                                    dataTableTotal.Rows.Add(dr);

                                    // 添加
                                    int maxStepIndex = ExperimentRunDetailDB.GetMaxStepIndexByRunChoiceBacteraId(ControlCom.ExpChoiceBactera().RunChoiceBacteraId) + 1;

                                    ExperimentRunDetailModel experimentRunDetail = new ExperimentRunDetailModel();
                                    experimentRunDetail.RunChoiceBacteraId = ControlCom.ExpChoiceBactera().RunChoiceBacteraId;
                                    experimentRunDetail.ExperimentId = Shared.Exp.ExperimentId;
                                    experimentRunDetail.StepIndex = maxStepIndex;
                                    experimentRunDetail.ExecuteMethod = "Choice";
                                    experimentRunDetail.SourcePosition = dataRow[dropdownNames[4].dropdown_name].ToString();
                                    experimentRunDetail.SourceBarcode = dataRow[dropdownNames[5].dropdown_name].ToString();
                                    experimentRunDetail.SourceWell = strWell[i];
                                    experimentRunDetail.Volume = Convert.ToDouble(dataRow[dropdownNames[7].dropdown_name]);
                                    experimentRunDetail.SourceStartTime = DateTime.Now;
                                    experimentRunDetail.SourceEndTime = DateTime.Now;
                                    experimentRunDetail.ExecSourceResult = (dataRow[dropdownNames[10].dropdown_name].ToString().Equals("pass") || dataRow[dropdownNames[10].dropdown_name].ToString().Equals("1")) ? 1 : 0;
                                    ExperimentRunDetailDB.Add(experimentRunDetail);
                                }
                            }

                            DataRow d = dataTableTotal.Rows[dataTableTotal.Rows.Count - countOfValid + i];
                            if (string.IsNullOrEmpty(d[dropdownNames[4].dropdown_name].ToString()))
                            {
                                d[dropdownNames[4].dropdown_name] = labwareLabel;
                                d[dropdownNames[5].dropdown_name] = strBarcode;
                                d[dropdownNames[6].dropdown_name] = strWell[i];
                                d[dropdownNames[7].dropdown_name] = volumn;
                                d[dropdownNames[9].dropdown_name] = startTime.ToString("yyyy-MM-dd HH:mm:ss:fff");
                                d[dropdownNames[10].dropdown_name] = result;

                                // 更新
                                int nStepIndex = Convert.ToInt32(d["StepIndex"].ToString());
                                ExperimentRunDetailModel experimentRunDetail = ExperimentRunDetailDB.GetInfodById(ControlCom.ExpChoiceBactera().RunChoiceBacteraId, nStepIndex);
                                experimentRunDetail.TargetPosition = labwareLabel;
                                experimentRunDetail.TargetBarcode = strBarcode;
                                experimentRunDetail.TargetWell = strWell[i];
                                experimentRunDetail.ActionName = "Coating";
                                experimentRunDetail.TargetStartTime = DateTime.Now;
                                experimentRunDetail.TargetEndTime = DateTime.Now;
                                experimentRunDetail.ExecTargetResult = (result.Equals("pass") || result.Equals("1")) ? 1 : 0;
                                ExperimentRunDetailDB.Update(experimentRunDetail);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 构建涂布报告结果数据文字描述
        public string GenerateCoatingReport(string imageName)
        {
            string strJson = string.Empty;
            DataTable dtResult = new DataTable();

            try
            {
                // 从拍照的json文件中，读取菌属性值，打包成涂布报告的格式
                string jsonFilePath = ConfigurationManager.AppSettings["captureFilePath"].ToString();
                string[] files = Directory.GetFiles(jsonFilePath);
                int fiMax = 1;

                foreach (string f in files)
                {
                    string f1 = f.Split('.')[0];
                    int startIndex = f1.LastIndexOf('\\');
                    string namestr = f1.Substring(startIndex + 1, f1.Length - startIndex - 1);
                    if (namestr.Contains("_原"))
                    {
                        continue;
                    }
                    int fileName = Convert.ToInt32(namestr);
                    if (fileName > fiMax)
                    {
                        fiMax = fileName;
                    }
                }

                string fullJsonFileName = jsonFilePath + "\\" + (fiMax).ToString() + ".json";
                ObservableCollection<BacteriaCoordinateEx> bacteriaCoordinates = DataModule.getInstance().GetBacteriaCoordinateList(fullJsonFileName);

                string jsonData = File.ReadAllText(fullJsonFileName);
                jsonData = jsonData.Replace("#!HxSEP!#", "");

                JObject job = JObject.Parse(jsonData);
                string barcode = job["barcode"].ToString();
                string countOfBacteria = job["count"].ToString();
                string color_str = string.Empty;
                string shape = string.Empty;
                string diameterSize = string.Empty;
                string proximity = string.Empty;
                JArray jArray = (JArray)job["germlist"];

                if (dataTableTotal.Rows.Count != 0)
                {
                    dtResult = dataTableTotal.Clone();
                    //再增加几个列
                    #region
                    DataColumn d = new DataColumn();
                    d.ColumnName = "barcode";
                    dtResult.Columns.Add(d);

                    d = new DataColumn();
                    d.ColumnName = "color_str";
                    dtResult.Columns.Add(d);

                    d = new DataColumn();
                    d.ColumnName = "shape";
                    dtResult.Columns.Add(d);

                    d = new DataColumn();
                    d.ColumnName = "diameterSize";
                    dtResult.Columns.Add(d);

                    d = new DataColumn();
                    d.ColumnName = "proximity";
                    dtResult.Columns.Add(d);
                    #endregion


                    foreach (JToken jt in jArray)
                    {
                        color_str = jt["color_str"].ToString();
                        shape = jt["shape"].ToString();
                        diameterSize = jt["diameterSize"].ToString();
                        proximity = jt["proximity"].ToString();
                        int index = Convert.ToInt32(jt["index"].ToString());

                        string coordinate3D = string.Empty;
                        string coordinate3Dx = jt["coordinate3D"]["x"].ToString();
                        string coordinate3Dy = jt["coordinate3D"]["y"].ToString();
                        string coordinate3Dz = jt["coordinate3D"]["z"].ToString();
                        coordinate3D = jt["coordinate3D"]["x"].ToString() + "," + jt["coordinate3D"]["y"].ToString() + "," + jt["coordinate3D"]["z"].ToString();

                        //拿坐标到涂布报表中搜寻相同的坐标
                        if (dataTableTotal.Rows.Count != 0)
                        {
                            for (int i = 0; i < dataTableTotal.Rows.Count; i++)
                            {
                                //if (dataTableTotal.Rows[i]["SourcePlateWell"].ToString() == coordinate3D)
                                //{
                                DataRow r = dtResult.NewRow();
                                r["CoatingDataId"] = dataTableTotal.Rows[i]["CoatingDataId"].ToString();
                                r["SourcePlateID"] = dataTableTotal.Rows[i]["SourcePlateID"].ToString();
                                r["SourcePlateBarcode"] = (dataTableTotal.Rows[i]["SourcePlateBarcode"] != null) ? dataTableTotal.Rows[i]["SourcePlateBarcode"].ToString() : "";
                                r["SourcePlateWell"] = dataTableTotal.Rows[i]["SourcePlateWell"].ToString();
                                r["TargetPlateID"] = dataTableTotal.Rows[i]["TargetPlateID"].ToString();
                                r["TargetPlateBarcode"] = dataTableTotal.Rows[i]["TargetPlateBarcode"].ToString();
                                r["TargetPlateWell"] = dataTableTotal.Rows[i]["TargetPlateWell"].ToString();
                                r["Volume"] = dataTableTotal.Rows[i]["Volume"].ToString();
                                r["StartActionTime"] = dataTableTotal.Rows[i]["StartActionTime"].ToString();
                                r["EndActionTime"] = dataTableTotal.Rows[i]["EndActionTime"].ToString();
                                r["ExcuteResult"] = dataTableTotal.Rows[i]["ExcuteResult"].ToString();
                                r["diameterSize"] = diameterSize.ToString();
                                r["shape"] = shape.ToString();
                                r["color_str"] = color_str.ToString();
                                r["proximity"] = proximity.ToString();
                                dtResult.Rows.Add(r);
                                //}
                            }
                        }
                    }
                }




                string j = JsonConvert.SerializeObject(dtResult);
                strJson = "{" +
                    "\"barcode\": \"" + barcode + "\"" +
                    ",\"countofbacteria\": " + countOfBacteria + "" +
                    ",\"image\": \"" + imageName + "\"" +
                    ",\"germlist\":" + j + "}";
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

            return strJson;
        }
        #endregion

        #region 构建涂布报告结果数据文字描述
        public string GenerateMoveLiquidReportBase()
        {
            string strJson = string.Empty;
            DataTable dtResult = new DataTable();

            //直接利用移液数据文件构建表结构
            dtResult.Columns.Add("CoatingDataId", typeof(string));
            dtResult.Columns.Add("SourceA", typeof(string));
            dtResult.Columns.Add("SourceBarcode", typeof(string));
            dtResult.Columns.Add("SourceWell", typeof(string));
            dtResult.Columns.Add("TargetB", typeof(string));
            dtResult.Columns.Add("TargetBarcode", typeof(string));
            dtResult.Columns.Add("TargetWell", typeof(string));
            dtResult.Columns.Add("Volume", typeof(string));
            dtResult.Columns.Add("StartActionTime", typeof(string));
            dtResult.Columns.Add("EndActionTime", typeof(string));
            dtResult.Columns.Add("ExcuteResult", typeof(int));

            try
            {
                if (dataTableTotal.Rows.Count != 0)
                {
                    //dtResult = dataTableTotal.Clone();

                    //拿坐标到涂布报表中搜寻相同的坐标
                    if (dataTableTotal.Rows.Count != 0)
                    {
                        for (int i = 0; i < dataTableTotal.Rows.Count; i++)
                        {
                            //if (dataTableTotal.Rows[i]["SourcePlateWell"].ToString() == coordinate3D)
                            //{
                            DataRow r = dtResult.NewRow();
                            r["CoatingDataId"] = dataTableTotal.Rows[i]["CoatingDataId"].ToString();
                            r["SourceA"] = dataTableTotal.Rows[i]["SourcePlateID"].ToString();
                            r["SourceBarcode"] = (dataTableTotal.Rows[i]["SourcePlateBarcode"] != null) ? dataTableTotal.Rows[i]["SourcePlateBarcode"].ToString() : "";
                            r["SourceWell"] = dataTableTotal.Rows[i]["SourcePlateWell"].ToString();
                            r["TargetB"] = dataTableTotal.Rows[i]["TargetPlateID"].ToString();
                            r["TargetBarcode"] = dataTableTotal.Rows[i]["TargetPlateBarcode"].ToString();
                            r["TargetWell"] = dataTableTotal.Rows[i]["TargetPlateWell"].ToString();
                            r["Volume"] = dataTableTotal.Rows[i]["Volume"].ToString();
                            r["StartActionTime"] = dataTableTotal.Rows[i]["StartActionTime"].ToString();
                            r["EndActionTime"] = dataTableTotal.Rows[i]["EndActionTime"].ToString();
                            r["ExcuteResult"] = dataTableTotal.Rows[i]["ExcuteResult"].ToString() == "pass" ? 1 : 0;
                            dtResult.Rows.Add(r);
                        }
                    }
                }




                string j = JsonConvert.SerializeObject(dtResult);
                strJson = j;//"{" +"\"germlist\":" + j + "}";
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog(ex.ToString());
            }

            return strJson;
        }

        public string GenerateMoveLiquidReport(string file)
        {
            string strJson = string.Empty;
            DataTable dtResult = new DataTable();

            //直接利用移液数据文件构建表结构
            string ext = Path.GetExtension(file);
            if (string.Compare(ext, ".csv", true) == 0)
            {
                dtResult = ExcelAndCsvHelper.GetDataTableFromCsvFile(file, false);
            }
            else
            {
                dtResult = ExcelAndCsvHelper.GetDataTableFromExcelFile(file, true);
            }
            DataColumn dataColumn = new DataColumn();
            dataColumn.ColumnName = "执行结果";
            dtResult.Columns.Add(dataColumn);

            try
            {
                if (dataTableTotal.Rows.Count != 0)
                {
                    //dtResult = dataTableTotal.Clone();

                    //拿坐标到涂布报表中搜寻相同的坐标
                    if (dataTableTotal.Rows.Count != 0)
                    {
                        for (int i = 0; i < dataTableTotal.Rows.Count; i++)
                        {
                            dtResult.Rows[i]["执行结果"] = dataTableTotal.Rows[i]["ExcuteResult"].ToString() == "pass" ? "成功" : "失败";
                        }
                    }
                }




                string j = JsonConvert.SerializeObject(dtResult);
                strJson = j;//"{" +"\"germlist\":" + j + "}";
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog(ex.ToString());
            }

            return strJson;
        }
        #endregion

        /// <summary>
        /// 添加台面布置格子
        /// </summary>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <param name="latticeNum"></param>
        /// <param name="isTrash"></param>
        /// <param name="nChoiceLatticeId"></param>
        /// <returns></returns>
        private Canvas AddTableItems(int row, int column, int latticeNum, bool isTrash)
        {
            Canvas canvas = new Canvas();
            if (nTableRows == 6 && nTableColumns == 6)
            {
                canvas.Margin = new Thickness(14, 6, 14, 6);
            }
            else
            {
                canvas.Margin = new Thickness(10, 10, 10, 10);
            }

            canvas.AllowDrop = true;
            canvas.Name = "P" + latticeNum.ToString();


            TextBlock tb = new TextBlock();
            tb.Text = "P" + latticeNum.ToString();
            tb.FontSize = 18;
            tb.Foreground = Brushes.Black;
            tb.VerticalAlignment = System.Windows.VerticalAlignment.Center;
            tb.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;

            Border border = new Border()
            {
                Background = Brushes.DarkGray,
                CornerRadius = new CornerRadius(5),
                Child = tb,
            };
            canvas.Children.Add(border);
            //grid.Drop += Canvas_Drop;
            //grid.PreviewMouseDown += Canvas_PreviewMouseDown;
            //grid.PreviewMouseMove += Canvas_PreviewMouseMove;
            //grid.QueryContinueDrag += DoQueryContinueDrag;
            //grid.PreviewDragOver += Canvas_PreviewDragOver;
            canvas.SizeChanged += Canvas_SizeChanged;
            //grid.ContextMenu = FindResource("tableMenu") as ContextMenu;

            if (isTrash)
            {
                ControlLabware cl = new ControlLabware()
                {
                    IsTrash = true,
                    LabwareName = Properties.Resources.strTrash.ToString()
                };
                LabwareEx lb = new LabwareEx();
                lb.labware_name = Properties.Resources.strTrash;
                canvas.DataContext = lb;
                canvas.Children.Add(cl);
            }
            Canvas.SetZIndex(canvas, 0);
            gridTable.Children.Add(canvas);
            Grid.SetColumn(canvas, column);
            Grid.SetRow(canvas, row);

            if (Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceLiteChoice ||
                Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceT200))
            {
                if (isTrash)
                {
                    Grid.SetColumnSpan(canvas, 1);
                    Grid.SetRowSpan(canvas, 3);
                }
                else if (latticeNum == mainWindow.ChoiceLatticeId)
                {
                    // P16、17合并单元格
                    Grid.SetColumnSpan(canvas, 1);
                    Grid.SetRowSpan(canvas, 2);

                    // 将Image控件添加到Canvas上
                    Image image = new Image();
                    image.Source = (ImageSource)(new ImageSourceConverter()).ConvertFrom(new Uri(@"pack://application:,,,/XHandler;component/Assets/dish_LiteChoice.png"));
                    image.Stretch = Stretch.Fill;
                    image.Width = canvas.Width - 4;
                    image.Height = canvas.Height - 23;

                    Canvas.SetLeft(image, 2);
                    Canvas.SetTop(image, 2);
                    canvas.Children.Add(image);
                    Panel.SetZIndex(image, 99);
                }
            }
            //else if (Shared.SoftwareInformation.software_device_number.Equals(DeviceCategory.DeviceLite))
            //{
            //    if (isTrash)
            //    {
            //        Grid.SetColumnSpan(canvas, 1);
            //        Grid.SetRowSpan(canvas, 3);
            //    }
            //}

            return canvas;
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            if (EventResponseController.Instance.CanExecute() == false)
                return;

            closeEvent?.Invoke(this, EventArgs.Empty);
        }

        private void Canvas_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            Canvas canvas = (Canvas)sender;
            if (canvas.Children.Count > 0)
            {
                Border bd = canvas.Children[0] as Border;
                bd.Width = canvas.ActualWidth;
                bd.Height = canvas.ActualHeight;
                //cl.LabwareWidth = canvas.ActualWidth - cl.LabwareDeep;
            }
            if (canvas.DataContext != null)
            {
                LabwareEx l = (LabwareEx)canvas.DataContext;
                if (string.IsNullOrEmpty(l.labware_type_id))
                {
                    ControlLabware cl = Utilities.FindVisualChild<ControlLabware>(canvas);
                    if (cl != null)
                    {
                        cl.Width = canvas.ActualWidth;
                        cl.Height = canvas.ActualHeight;
                    }
                }
                else
                {
                    if (canvas.Children.Count > 1)
                    {
                        ControlLabware cl = Utilities.FindVisualChild<ControlLabware>(canvas);
                        if (cl != null)
                        {
                            cl.Width = canvas.ActualWidth;
                            cl.Height = canvas.ActualHeight;
                        }
                    }
                }
            }

            // 挑菌位图片大小适配
            if (canvas.Name.Equals(ConfigurationManager.AppSettings["choiceLatticeId"].ToString()))
            {
                Image img = Utilities.FindVisualChild<Image>(canvas);
                if (img != null)
                {
                    img.Width = canvas.ActualWidth - 4;
                    img.Height = canvas.ActualHeight - 23;
                }

                ControlLabware cl = Utilities.FindVisualChild<ControlLabware>(canvas);
                if (cl != null)
                {
                    cl.LabwareWidth = canvas.ActualWidth - 10;
                    cl.LabwareHeight = canvas.ActualHeight / 2;
                }
            }
        }

        /// <summary>
        /// 添加运行日志
        /// </summary>
        /// <param name="log"></param>
        public void AddLogs(string log)
        {
            lock (m_lockTipMsg)
            {
                if (isRemotingOper)//如果是远程运行不添加日志到界面
                {
                    LoggerRunHelper.InfoLog(log);
                }
                else
                {
                    System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                    {
                        logList.Add(log);
                        if (logList.Count > Convert.ToInt32(ConfigurationManager.AppSettings["runLogCnt"]))
                        {
                            logList.RemoveAt(0);
                        }

                        logListbox.ScrollIntoView(log);
                        LoggerRunHelper.InfoLog(log);

                    }));
                }
            }
        }

        public void UpdateInvalidStatus(string position, string wells)
        {
            if (!isRemotingOper)
            {
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    foreach (Canvas canvas in gridTable.Children)
                    {
                        if (canvas.Name == position)
                        {
                            LabwareEx labwareEx = canvas.DataContext as LabwareEx;
                            ControlLabware labware = Utilities.FindVisualChild<ControlLabware>(canvas);
                            if (labwareEx != null && labware != null)
                            {
                                labware.UpdateWells(wells, Colors.Green);
                            }
                            break;
                        }
                    }
                }));
            }
        }


        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            SetRunningStatus("3");
        }

        private void Button_Click_3(object sender, RoutedEventArgs e)
        {
            SetErrorStatus("4-1");
        }

        /// <summary>
        /// 设置节点状态
        /// </summary>
        /// <param name="indexName"></param>
        private void SetRunningStatus(string indexName)
        {
            if (isRemotingOper)
            {
                return;
            }
            MethodEx methodEx = FindMethodExByIndex(rootMethod, indexName);
            if (methodEx != null)
            {
                //methodEx.isSelected = true;
                methodEx.IsError = 2;
                //Dispatcher.Invoke(new Action(() =>
                //{
                //    runTreeviewWorkflow.UpdateLayout();
                //}), DispatcherPriority.Background);

                //滚动条跟随，只支持第一层跟随
                Dispatcher.Invoke(new Action(() =>
                {
                    TreeViewItem item = runTreeviewWorkflow.ItemContainerGenerator.ContainerFromItem(methodEx) as TreeViewItem;
                    if (item != null)
                    {


                        // 将TreeViewItem设置为焦点
                        item.Focus();

                        // 滚动TreeViewItem到视图中
                        item.BringIntoView();


                    }
                }), DispatcherPriority.Background);
            }

            //runTreeviewWorkflow.UpdateLayout();
            //runTreeviewWorkflow.BringIntoView(new Rect(runTreeviewWorkflow.s));
        }

        //private void myTreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
        //{
        //    if (runTreeviewWorkflow.SelectedItem != null)
        //    {
        //        // 计算并设置ScrollViewer的ScrollOffset
        //        // 注意：此处的TreeViewItemContainerGenerator可能需要你根据实际的TreeView命名进行调整
        //        var itemContainer = runTreeviewWorkflow.ItemContainerGenerator.ContainerFromItem(runTreeviewWorkflow.SelectedItem) as UIElement;
        //        if (itemContainer != null)
        //        {
        //            double itemTop = itemContainer.TranslatePoint(new System.Windows.Point(0, 0), runTreeviewWorkflow).Y;
        //            double scrollTop = runTreeviewWorkflow.ScrollViewer.VerticalOffset;
        //            double scrollOffset = itemTop + scrollTop - runTreeviewWorkflow.ScrollViewer.ViewportHeight / 2;
        //            runTreeviewWorkflow.ScrollViewer.ScrollToVerticalOffset(scrollOffset);
        //        }
        //    }
        //}

        private void SetErrorStatus(string indexName)
        {
            if (isRemotingOper)
            {
                return;
            }
            MethodEx methodEx = FindMethodExByIndex(rootMethod, indexName);
            if (methodEx != null)
                methodEx.IsError = 1;
        }

        private MethodEx FindMethodExByIndex(MethodEx method, string indexName)
        {
            if (method.strIndex == indexName)
                return method;
            else
            {
                if (method.Children.Count > 0)
                {
                    foreach (var m in method.Children)
                    {
                        MethodEx find = FindMethodExByIndex(m, indexName);
                        if (find != null)
                            return find;
                    }
                }
                else
                    return null;
            }
            return null;
        }

        #region 运行按钮事件
        public static bool IsRunning = false;
        public static bool hadRun = false;//是否运行过，如果运行过就不重新初始化
        public async void btnPlay_Click(object sender, RoutedEventArgs e)
        {
            if (IsRunning)
            {
                #region Del
                //bool isContinue = dicManualResetEvent[batchId].WaitOne(300);
                //if (!isContinue)
                //{
                //    // 解除暂停
                //    ReleasePause();
                //}
                #endregion
                return;
            }

            PlsToolTipWin plsToolTipWin = null;
            SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(70, 0, 0, 0));

            #region 开关门检查
            if (!EnableSimulator && mainWindow.IsOpenDoor &&
                "true" == ConfigurationManager.AppSettings.Get("isCheckOpenDoor"))
            {
                Application.Current.Dispatcher.Invoke(new Action(() =>
                {
                    // 状态4 运行 绿色；
                    CommonBll.StatusLamp(4, EnableSimulator);
                    // 状态6 报错/急停 红闪/蜂鸣5S；
                    CommonBll.StatusLamp(6, EnableSimulator);

                    plsToolTipWin = new PlsToolTipWin("请关闭设备推拉门后再启动实验！");
                    plsToolTipWin.Height = this.ActualHeight;
                    plsToolTipWin.Width = this.ActualWidth;
                    plsToolTipWin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                    plsToolTipWin.btnCancel.Visibility = Visibility.Hidden;
                    plsToolTipWin.ShowDialog();
                }));

                return;
            }
            #endregion

            //plsToolTipWin = new PlsToolTipWin("运行最后一次加载的方法？");
            //plsToolTipWin.Height = ActualHeight;
            //plsToolTipWin.Width = ActualWidth;
            //plsToolTipWin.btnClearData.Visibility = Visibility.Visible;
            //plsToolTipWin.lauchView = this;
            //plsToolTipWin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
            //plsToolTipWin.ShowDialog();

            this.xmlDocument = mainWindow.RefreshRunXml();
            RunAgoTips RunAgoTips = new RunAgoTips(this);
            RunAgoTips.ShowDialog();

            if (RunAgoTips.DialogResult == true)
            {
                BtnIsEnabled(1);
                tbxRunTip.Text = string.Empty;

                gloadVariable.Clear();
                VariableDictionary.Clear();

                // 状态灯:状态4 运行        绿色；
                HxResult ret = CommonBll.StatusLamp(4, EnableSimulator);
                batchId = Guid.NewGuid().ToString();
                dicManualResetEvent.Add(batchId, new ManualResetEvent(true));

                if (hadRun)
                {
                    hadRun = false;
                    if (tbxRunTitle.Text.Equals("模拟运行"))
                    {
                        EnableSimulator = true;
                    }
                    mainWindow.RefreshRunResult();
                    _cancelSource = new CancellationTokenSource();
                    isLoop1Start = false;
                }

                #region 调用运行方法
                try
                {
                    IsRunning = true;
                    hadRun = true;
                    TaskFactory taskFactory = new TaskFactory();
                    int iresult = await LoadLabwareOnRunning();
                }
                catch (Exception ex)
                {
                    LoggerHelper.ErrorLog("ERROR:", ex);
                }
                finally
                {
                    IsRunning = false;
                    Shared.Exp = null;
                    Shared.ExpChoiceBactera = null;
                    selectedMethodEx = null;
                }
                #endregion

                BtnIsEnabled(5);
            }
        }
        #endregion

        #region 暂停按钮事件
        int pauseState = 0;     //1:暂停状态；0：正常状态
        public void btnPause_Click(object sender, RoutedEventArgs e)
        {
            // 操作流程
            OperateExpFolw(false);
        }

        /// <summary>
        /// 操作流程
        /// </summary>
        /// <param name="isAutoFlg"></param>
        public void OperateExpFolw(bool isAutoFlg = false)
        {
            if (!IsRunning)
            {
                LoggerHelper.InfoLog(string.Format("[OperateExpFolw]: IsRunning = false, 无可用流程操作 return."));
                return;
            }

            bool isPause = false;

            if (!isAutoFlg)
            {
                // pauseState = 0：正常状态 => 暂停
                isPause = pauseState == 0 ? true : false;
            }
            else
            {
                isPause = mainWindow.IsOpenDoor ? true : false;
            }

            Application.Current.Dispatcher.Invoke(new Action(() =>
            {
                // 想要暂停 && 0：正常状态
                if (isPause && pauseState == 0)
                {
                    pauseState = 1;     // 保持暂停
                    dicManualResetEvent[batchId].Reset();

                    btnPause.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/pausedisable.png"));

                    // 状态5 暂停 黄色
                    CommonBll.StatusLamp(5, EnableSimulator);
                    // 1=暂停
                    MethodAction.Instance.Interrupt(1, true);

                    BtnIsEnabled(3);

                    tbxRunTip.Text = Properties.Resources.strExpPaused;
                }
                // 想要继续 && 1：暂停状态
                else if (!isPause && pauseState == 1)
                {
                    pauseState = 0;     // 解除暂停
                    dicManualResetEvent[batchId].Set();
                    btnPause.IsEnabled = true;
                    btnPause.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/pause.png"));

                    // 状态4 运行 绿色
                    CommonBll.StatusLamp(4, EnableSimulator);
                    // 2=继续
                    MethodAction.Instance.Interrupt(2);

                    BtnIsEnabled(2);

                    tbxRunTip.Text = string.Empty;
                }
                else
                {
                    LoggerHelper.InfoLog(string.Format("[OperateExpFolw]: isPause = {0}, pauseState = {1}, return.", isPause, pauseState));
                }
            }));
        }
        #endregion

        #region 停止按钮事件
        private async void btnStop_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                PlsToolTipWin plsToolTipWin = new PlsToolTipWin("确定要停止运行吗？");
                plsToolTipWin.ShowDialog();
                if (plsToolTipWin.DialogResult != true)
                {
                    return;
                }

                // 先点暂停、再点停止
                _cancelSource.Cancel();
                // 状态7 运行结束 蓝闪/蜂鸣5S
                HxResult ret = CommonBll.StatusLamp(7, EnableSimulator);
                // 3=停止
                ret = await Task.Factory.StartNew(() => MethodAction.Instance.Interrupt(3, true));

                if (ret.Result != ResultType.Success)
                {
                }
                else
                {
                    IsRunning = false;
                    isLoop1Start = false;

                    btnPause.IsEnabled = true;
                    btnPause.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/pause.png"));
                }

                BtnIsEnabled(4);
                tbxRunTip.Text = string.Empty;
                pauseState = 0;

                //if (_cancelSource.IsCancellationRequested)
                //{
                //    _cancelSource = new CancellationTokenSource();
                //}
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 返回实验设计
        private void btnGoBack_Click(object sender, RoutedEventArgs e)
        {
            if (mainWindow != null)
            {
                mainWindow.btnStartFirstPage_Click(sender, e);
                mainWindow.btnTestDesign.IsChecked = true;
                mainWindow.ShowTestDesign();
                mainWindow.btnOpen.IsEnabled = true;
            }
        }
        #endregion

        #region 获取运行时台面对应格子的Canvas
        /// <summary>
        /// 获取台面对应格子的Canvas
        /// </summary>
        /// <param name="row"></param>
        /// <param name="col"></param>
        /// <returns></returns>
        private Canvas GetGridTableCanvas(int row, int col)
        {
            foreach (var canvasItem in gridTable.Children)
            {
                Canvas canvas = canvasItem as Canvas;
                int curColumnIndex = Grid.GetColumn(canvas);
                int curRowIndex = Grid.GetRow(canvas);

                if (row == curRowIndex && col == curColumnIndex)
                {
                    return canvas;
                }
            }

            return null;
        }
        #endregion

        #region 根据台面板位编号获取台面板位对象
        private Canvas GetGridTableCanvasByNum(string latticeNum)
        {
            foreach (var canvasItem in gridTable.Children)
            {
                Canvas canvas = canvasItem as Canvas;
                if(canvas.Name.Equals(latticeNum))
                {
                    return canvas;
                }
            }

            return null;
        }
        #endregion

        #region 获取实验设计台面对应格子的Canvas
        /// <summary>
        /// 获取实验设计台面对应格子的Canvas
        /// </summary>
        /// <param name="row"></param>
        /// <param name="col"></param>
        /// <returns></returns>
        private Canvas GetGridTableCanvasOnDesign(int row, int col)
        {
            if (mainWindow != null)
            {
                foreach (var canvasItem in mainWindow.testDesign.gridTable.Children)
                {
                    Canvas canvas = canvasItem as Canvas;
                    int curColumnIndex = Grid.GetColumn(canvas);
                    int curRowIndex = Grid.GetRow(canvas);

                    if (row == curRowIndex && col == curColumnIndex)
                    {
                        return canvas;
                    }
                }
            }

            return null;
        }
        #endregion

        /// <summary>
        /// 设置启停信号量
        /// </summary>
        public void SetWaitOne()
        {
            try
            {
                if (batchId == string.Empty || dicManualResetEvent.Count == 0)
                {
                    return;
                }
                if (dicManualResetEvent[batchId] == null)
                {
                    return;
                }

                dicManualResetEvent[batchId].WaitOne();
            }
            catch (Exception ex)
            {
                return;
            }
        }

        /// <summary>
        /// 按钮是否启用
        /// </summary>
        /// <param name="flag">1 开始运行、2 暂停、3 继续、4 停止、 5流程结束</param>
        private void BtnIsEnabled(int flag)
        {
            switch (flag)
            {
                case 1:
                    btnPlay.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/playdisable.png"));
                    btnStop.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/stop.png"));
                    btnPause.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/pause.png"));
                    btnPlay.IsEnabled = false;
                    btnStop.IsEnabled = true;
                    btnPause.IsEnabled = true;
                    break;
                case 2:
                    btnPlay.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/playdisable.png"));
                    btnPause.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/pause.png"));
                    btnStop.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/stop.png"));
                    btnPlay.IsEnabled = false;
                    btnPause.IsEnabled = true;
                    btnStop.IsEnabled = true;
                    break;
                case 3:
                    btnPlay.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/playdisable.png"));
                    btnPause.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/pause.png"));
                    btnStop.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/stop.png"));
                    btnPlay.IsEnabled = false;
                    btnPause.IsEnabled = true;
                    btnStop.IsEnabled = true;
                    break;
                case 4:
                    btnPlay.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/play.png"));
                    btnStop.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/stopdisable.png"));
                    btnPause.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/pausedisable.png"));
                    btnPlay.IsEnabled = true;
                    btnStop.IsEnabled = false;
                    btnPause.IsEnabled = false;
                    break;
                case 5:
                    btnPlay.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/play.png"));
                    btnStop.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/stopdisable.png"));
                    btnPause.NormalImage = new BitmapImage(new Uri("pack://application:,,,./Assets/Run/pausedisable.png"));
                    btnPlay.IsEnabled = true;
                    btnStop.IsEnabled = false;
                    btnPause.IsEnabled = false;
                    break;
            }
        }

        #region 添加运行实验
        public ExperimentModel AddExp(string xmlContent)
        {
            ExperimentModel experiment = new ExperimentModel();

            try
            {
                experiment.ExperimentId = DateTime.Now.ToString("yyyyMMddHHmmss");
                string methodFileName = mainWindow.CurWorkFlowName;
                experiment.ExperimentName = string.Empty;
                if (methodFileName.Length > 0)
                {
                    experiment.ExperimentName = methodFileName.Substring(methodFileName.LastIndexOf('\\') + 1, methodFileName.Length - methodFileName.LastIndexOf('\\') - 1);
                }
                
                experiment.ExperimentXmlContent = xmlContent;
                experiment.ExperimentFile = methodFileName.Replace("\\", "\\\\");
                experiment.LunchTime = DateTime.Now;
                experiment.Status = EnumManagement.GetEnumValue(ExpStatusEnum.Running);
                experiment.OperaterName = Shared.User.username;

                ExperimentDB.Add(experiment);
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("添加运行记录时错误：" + ex.ToString());
            }
            return experiment;
        }
        #endregion

        #region 台面加载完成后，数据的处理
        private void gridTable_Loaded(object sender, RoutedEventArgs e)
        {
            double xVal = gridTable.ActualWidth;
            double yVal = gridTable.ActualHeight;
        }
        #endregion

        #region 运行界面时，右键子方法的节点弹出菜单
        private void runTreeviewWorkflow_PreviewMouseRightButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            DependencyObject source = e.OriginalSource as DependencyObject;
            while (source != null && source.GetType() != typeof(TreeViewItem))
                source = VisualTreeHelper.GetParent(source);
            if (source != null)
            {
                TreeViewItem item = source as TreeViewItem;
                item.IsSelected = true;
                MethodEx mEx = item.DataContext as MethodEx;
                ContextMenu menu = FindResource("workflowMenu") as ContextMenu;
                MenuItem menuItem = menu.Items[0] as MenuItem;

                int iNum = methodListBll.getNumByMethodName(mEx.method_name);

                menuItem.IsEnabled = (iNum==(int)MethodNameEnum.subMethod) ? true : false;
            }
        }
        #endregion

        private void workflowMenuRunStatus_Click(object sender, RoutedEventArgs e)
        {
            // 打开子方法流程状态页面
            ViewCom.OpenSubMethodWorkflow(runTreeviewWorkflow);
        }
    }
}