using DataEntity.Share;
using DataRWDAL;
using DataRWDalDrive.DB;
using HandyControl.Data;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Runtime.Remoting.Channels;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using XCommon.Log;
using XCommon.Tip;
using XCore;
using XHandler.Class;
using XHandler.Class.DataEx;
using XHandler.Controls;
using XImagingXhandler.XDAL;
using XHandler.View.Liquids;
using XHandler.View.Device;
using DataEntity;

namespace XHandler.View.MethodProperty
{
    /// <summary>
    /// AspirateProperty.xaml 的交互逻辑
    /// </summary>
    public partial class AspirateProperty : UserControl, IMethodProperty,ILiquidObserver,ILatticeObserver,IDeviceArmObserver
    {
        public MethodAspirate methodAspirate { get; set; }

        public MethodAspirate currmethodAspirate = null;
        public MethodEx method = null;

        #region 全局属性变量
        string isrun = "";
        string status = "";
        string name = "";
        string label = "";
        string labwareText = "";
        string labwareValue = "";
        string positionText = "";
        string positionValue = "";
        string armText = "";
        string armValue = "";
        string labwaretipText = "";
        string labwaretipValue = "";
        private int[] channels = Shared.ChannelsId;
        string wellarray = "";
        bool enableSingleWellvolume = false;
        List<DropdownName> singlewellvolume = null;
        public double wellvolume = 0.0d;
        string liquididText = "";
        string liquididValue = "";
        string liquidrangeidText = "";
        string liquidrangeidValue = "";
        string liquidpidText = "";
        string liquidpidValue = "";
        bool bMix = false;
        bool bMultiMix = false;
        double mixvolume = 0.0d;
        int mixcount = 0;
        string mixAspiratePositionText = "";
        int mixAspiratePositionValue = 0;
        double mixAspirateDistance = 0.0d;
        double mixAspirateSpeed = 0.0d;
        string mixDispensePositionText = "";
        int mixDispensePositionValue = 0;
        double mixDispenseDistance = 0.0d;
        double mixDispenseSpeed = 0.0d;

        bool enableLiquidSensor = false;
        int liquidSensorCount = 0;
        double liquidSensorDistance = 0.0d;
        double liquidSensorEndDistance = 0.0d;
        double liquidSensorSpeed = 10d;
        double liquidSensorRadio = 10d;
        string liquidSensorDisIdText = "";
        double liquidSensorDisIdValue = 0.0d;
        bool enableLiquidFollow = false;
        int liquidFollowType = 0;
        string liquidFollowTypeName = "";
        double liquidFollowSpeed = 0.0d;
        double liquidFollowDistance = 0.0d;
        double liquidFollowArea = 0.0d;
        bool enableMixFollow = false;

        bool enableSensorBlock = false;
        //double liquidSensorBlockDistance = 0.0d;
        string aspirateBlockDisIdText = "";
        int aspirateBlockDisIdValue = 0;
        string aspirateAirDisIdText = "";
        int aspirateAirDisIdValue = 0;

        int mark = 0;
        #endregion

        AspirateBll aspirateBll = new AspirateBll();
        private Labware selectedLabware = null;
        int curArmSelectedIndex = -1;
        int curLiquidTypeSelectedIndex = -1;
        int curLiquidRangeSelectedIndex = -1;
        int curLiquidSelectedIndex = -1;
        int curMixAspirateSelectIndex = -1;
        int curMixDispenseSelectIndex = -1;

        public AspirateProperty()
        {
            InitializeComponent();
        }

        bool isLiquidUpdate = false;
        /// <summary>
        /// 液体参数变更后，更新节点
        /// </summary>
        /// <param name="liquidManagement">液体参数管理对象</param>
        public void ReceiveAndUpdate(LiquidManagement liquidManagement)
        {
            isLiquidUpdate = true;

            ObservableCollection<LiquidType> liquidTypeList = DataModule.getInstance().GetLiquidTypes();
            cbLiquidType.ItemsSource = liquidTypeList;
            cbLiquidType.SelectedIndex = -1;
            cbLiquidType.SelectedValue = methodAspirate.liquididValue;

            ObservableCollection<LiquidRange> liquidRangeList = DataModule.getInstance().GetLiquidRanges();
            cbLiquidRange.ItemsSource = liquidRangeList.OrderBy(m => Convert.ToInt32(m.liquid_range_id));
            cbLiquidRange.SelectedIndex = -1;
            cbLiquidRange.SelectedValue = methodAspirate.liquidrangeidValue;

            if (methodAspirate.liquidpidValue == "")
            {
                cbLiquid.SelectedIndex = 0;
            }
            else
            {
                cbLiquid.SelectedValue = methodAspirate.liquidpidValue;
            }

        }

        /// <summary>
        /// 实验设计台面耗材位置变更后，更新节点
        /// </summary>
        /// <param name="testDesign"></param>
        public void ReceiveAndUpdate(TestDesign testDesign)
        {
            if(testDesign.srcCanvas!=null&&testDesign.targetCanvas!=null)
            {
                //判断当前的台面选择是不是来源位置上的，如果是就更新，不是就不更新
                if (comboboxTablePos.SelectedItem.ToString() == testDesign.srcCanvas.Name)
                {
                    SetTableName(testDesign.targetCanvas.Name, (Labware)(((ControlLabware)testDesign.targetCanvas.Children[testDesign.targetCanvas.Children.Count - 1]).DataContext));
                }
                else
                {

                }
            }
        }

        /// <summary>
        /// 通道设置变更后，更新节点
        /// </summary>
        /// <param name="testDesign"></param>
        public void ReceiveAndUpdate()
        {
            try
            {
                // 获取当前设备臂信息
                List<DeviceArm> deviceArmList = DeviceArmDB.GetDeviceArmFromdb(Shared.SoftwareInformation.software_information_id);
                Shared.DeviceArmList = deviceArmList;
                DeviceArm deviceArm = Shared.DeviceArmList.SingleOrDefault(x => x.software_information_id.Equals(Shared.SoftwareInformation.software_information_id) && x.device_arm_id.Equals((cbArm.SelectedItem as DeviceArm).device_arm_id) && x.arm_type.Equals(1));
                tipsChannel.TotalChannels = deviceArm.channels;
                tipsChannel.SetTotalChannelCount(deviceArm.channels);
                if (deviceArm.device_arm_property == "")
                {
                    tipsChannel.SelectedChannels = new List<int> { };
                    tipsChannel.SetSelectedChannels();
                    //Shared.ChannelsId = new int[];
                    return;
                }
                string[] strChannels = deviceArm.device_arm_property.Trim().Split(',');
                int[] iChannels = new int[strChannels.Length];
                for (int j = 0; j < strChannels.Length; j++)
                {
                    iChannels[j] = Convert.ToInt32(strChannels[j]);
                }

                if (iChannels.Length > 0)
                {
                    tipsChannel.SelectedChannels = iChannels.ToList();
                    tipsChannel.SetSelectedChannels();
                }

                if (methodAspirate != null)
                {
                    methodAspirate.channels = iChannels;
                }
            }
            catch(Exception ex)
            {
                LoggerHelper.ErrorLog("ReceiveAndUpdate ERROR:", ex);
            }
        }


        public AspirateProperty(MethodEx method)
        {
            mark = 0;
            InitializeComponent();

            curArmSelectedIndex = 0;
            curLiquidTypeSelectedIndex = 0;
            curLiquidRangeSelectedIndex = 0;
            curLiquidSelectedIndex = 0;
            curMixAspirateSelectIndex = 0;
            curMixDispenseSelectIndex = 0;

            List<DeviceArm> armList = DataModule.getInstance().GetDeviceArm();
            cbArm.ItemsSource = armList;
            if (armList.Count == 2) //只有一个臂的情况下默认选中该臂
                curArmSelectedIndex = 1;
            else
                curArmSelectedIndex = 0;

            ObservableCollection<LiquidType> liquidTypeList = DataModule.getInstance().GetLiquidTypes();
            cbLiquidType.ItemsSource = liquidTypeList;

            ObservableCollection<LiquidRange> liquidRangeList = DataModule.getInstance().GetLiquidRanges();
            cbLiquidRange.ItemsSource = liquidRangeList.OrderBy(m => Convert.ToInt32(m.liquid_range_id));

            ObservableCollection<Liquid> liquidList = new ObservableCollection<Liquid>();
            Liquid liquid = new Liquid();
            liquid.liquid_name = Properties.Resources.strPleaseSelect;
            liquidList.Add(liquid);
            cbLiquid.ItemsSource = liquidList;

            gdLiquidFollow.RowDefinitions[1].Height = new GridLength(0);
            gdLiquidFollow.RowDefinitions[2].Height = new GridLength(0);
            gdLiquidFollow.RowDefinitions[3].Height = new GridLength(0);
            gdLiquidFollow.RowDefinitions[4].Height = new GridLength(0);

            if (Shared.ChannelCount > 1)
            {
                tipsChannel.CanEdit = true;

                if (Shared.ChannelCount.Equals(96))
                {
                    tipsChannel.Visibility = Visibility.Collapsed;
                }
            }

            List<string> list = new List<string>();
            List<Lattice> lattices = DataModule.getInstance().GetLattices();
            TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();  //增加台面模板判断
            if (tabletopTemplate == null)
            {
                for (int i = 0; i < Shared.SoftwareInformation.columns; i++)
                {
                    for (int j = 0; j < Shared.SoftwareInformation.rows; j++)
                    {
                        int tmp = i * Shared.SoftwareInformation.rows + j;
                        Lattice latt = lattices[tmp];
                        if (latt.is_trash == 1)
                            continue;
                        list.Add(latt.lattice_num);
                    }
                }
            }
            else
            {
                foreach(Lattice lattice in lattices)
                {
                    if (lattice.is_trash == 1)
                        continue;
                    list.Add(lattice.lattice_num);
                }
            }
            //list.Insert(0, Properties.Resources.strPleaseSelect);
            comboboxTablePos.ItemsSource = list;
            comboboxTablePos.SelectedIndex = 0;

            if (Shared.ChannelCount.Equals(96))
            {
                tbxWellPositionTips.IsEnabled = false;
                wellPlate.IsEnabled = false;
            }

            List<string> mixPositionList = new List<string>();
            mixPositionList.Add(MixPositionEnum.Liquid.ToString());
            mixPositionList.Add(MixPositionEnum.Top.ToString());
            mixPositionList.Add(MixPositionEnum.Bottom.ToString());
            cbMixAspiratePosition.ItemsSource = mixPositionList;
            cbMixDispensePosition.ItemsSource = mixPositionList;
            tbxCommandLabel.Text = method.method_name;

            ObservableCollection<string> listProcess = DataModule.getInstance().GetUndetectProcessList();
            cbxLiquidSensorDisId.ItemsSource = listProcess;

            ObservableCollection<string> listAspirateBlockProcess = DataModule.getInstance().GetAspirateBlockDealTypeList();
            cbxAspirateBlockDealType.ItemsSource = listAspirateBlockProcess;

            ObservableCollection<string> listAspirateAirProcess = DataModule.getInstance().GetAspirateAirDealTypeList();
            cbxAspirateAirDealType.ItemsSource = listAspirateAirProcess;

            ObservableCollection<string> listLiquidFollowType = DataModule.getInstance().GetLiquidFollowTypeList();
            cbxLiquidFollowType.ItemsSource = listLiquidFollowType;

            methodAspirate = new MethodAspirate();
            methodAspirate.name = method.method_name;
            methodAspirate.label = method.method_name;
            methodAspirate.status = (method.isEnabled == true ? "enable" : "disable");
            methodAspirate.wellarray = "";
            methodAspirate.strIndex = method.strIndex;


            this.method = method;
            if (method.tag != null)
            {
                methodAspirate = (MethodAspirate)method.tag;

                currmethodAspirate = methodAspirate;

                isrun = methodAspirate.isrun;
                status = methodAspirate.status;
                name = methodAspirate.name;
                label = methodAspirate.label;
                labwareText = methodAspirate.labwareText;
                labwareValue = methodAspirate.labwareValue;
                positionText = methodAspirate.positionText;
                positionValue = methodAspirate.positionValue;
                armText = methodAspirate.armText;
                armValue = methodAspirate.armValue;
                labwaretipText = methodAspirate.labwaretipText;
                labwaretipValue = methodAspirate.labwaretipValue;

                channels = methodAspirate.channels;

                wellarray = methodAspirate.wellarray;
                enableSingleWellvolume = methodAspirate.enableSingleWellvolume;
                singlewellvolume = methodAspirate.singlewellvolume;
                wellvolume = methodAspirate.wellvolume;
                liquididText = methodAspirate.liquididText;
                liquididValue = methodAspirate.liquididValue;
                liquidrangeidText = methodAspirate.liquidrangeidText;
                liquidrangeidValue = methodAspirate.liquidrangeidValue;
                liquidpidText = methodAspirate.liquidpidText;
                liquidpidValue = methodAspirate.liquidpidValue;
                bMix = methodAspirate.bMix;
                bMultiMix = methodAspirate.bMultiMix;
                mixvolume = methodAspirate.mixvolume;
                mixcount = methodAspirate.mixcount;
                mixAspiratePositionText = methodAspirate.mixAspiratePositionText;
                mixAspiratePositionValue = methodAspirate.mixAspiratePositionValue;
                mixAspirateDistance = methodAspirate.mixAspirateDistance;
                mixAspirateSpeed = methodAspirate.mixAspirateSpeed;
                mixDispensePositionText = methodAspirate.mixDispensePositionText;
                mixDispensePositionValue = methodAspirate.mixDispensePositionValue;
                mixDispenseDistance = methodAspirate.mixDispenseDistance;
                mixDispenseSpeed = methodAspirate.mixDispenseSpeed;

                enableLiquidSensor = methodAspirate.enableLiquidSensor;
                liquidSensorCount = methodAspirate.liquidSensorCount;
                liquidSensorDistance = methodAspirate.liquidSensorDistance;
                liquidSensorEndDistance = methodAspirate.liquidSensorEndDistance;
                liquidSensorSpeed=methodAspirate.liquidSensorSpeed;
                liquidSensorRadio=methodAspirate.liquidSensorRadio;
                liquidSensorDisIdText = methodAspirate.liquidSensorDisIdText;
                liquidSensorDisIdValue = methodAspirate.liquidSensorDisIdValue;
                enableLiquidFollow=methodAspirate.enableLiquidFollow;
                liquidFollowType=methodAspirate.liquidFollowType;
                liquidFollowTypeName=methodAspirate.liquidFollowTypeName;
                liquidFollowSpeed=methodAspirate.liquidFollowSpeed;
                liquidFollowDistance=methodAspirate.liquidFollowDistance;
                liquidFollowArea=methodAspirate.liquidFollowArea;
                enableMixFollow=methodAspirate.enableMixFollow;

                enableSensorBlock = methodAspirate.enableSensorBlock;
                //liquidSensorBlockDistance = methodAspirate.liquidSensorBlockDistance;
                aspirateBlockDisIdText = methodAspirate.aspirateBlockDisIdText;
                aspirateBlockDisIdValue = methodAspirate.aspirateBlockDisIdValue;
                aspirateAirDisIdText = methodAspirate.aspirateAirDisIdText;
                aspirateAirDisIdValue = methodAspirate.aspirateAirDisIdValue;
            }
            this.DataContext = methodAspirate;
            LiquidManagement.loadLiquidsEvent += BindLiquids;
        }

        public void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            mark += 1;
            try
            {
                if (mark > 1)
                {
                    return;
                }
                int[] ichs = channels;
                if (!string.IsNullOrEmpty(armText))
                {
                    tbxCommandName.Text = name;
                    cbArm.SelectedValue = armValue;
                    DeviceArm arm = cbArm.SelectedItem as DeviceArm;
                    tbxHeadType.Text = arm.head_type;
                    comboboxTablePos.SelectedItem = positionText;

                    //根据板位上的耗材类型，显示耗材孔位示意图
                    Labware labwareA = DataRWDAL.LabwareDB.GetLabware(methodAspirate.labwareValue);

                    wellPlate.Rows = labwareA.number_row;
                    wellPlate.Columns = labwareA.number_column;

                    if (labwareA.labware_type_id.Equals("4"))
                    {
                        labwareA.labwareWellInfoList = DataRWDAL.LabwareDB.GetSpecialLabwareWellInfo(labwareA.labware_id);
                        wellPlate.labwareWellInfoList = labwareA.labwareWellInfoList;
                        wellPlate.LabwareRealWidth = labwareA.labware_length;
                        wellPlate.LabwareRealLength = labwareA.labware_width;
                    }

                    if (Shared.ChannelCount.Equals(96))
                    {
                        tbxWellPositionTips.IsEnabled = false;
                        wellPlate.IsEnabled = false;
                        wellarray = "A1,B1,C1,D1,E1,F1,G1,H1,A2,B2,C2,D2,E2,F2,G2,H2,A3,B3,C3,D3,E3,F3,G3,H3,A4,B4,C4,D4,E4,F4,G4,H4,A5,B5,C5,D5,E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8,A9,B9,C9,D9,E9,F9,G9,H9,A10,B10,C10,D10,E10,F10,G10,H10,A11,B11,C11,D11,E11,F11,G11,H11,A12,B12,C12,D12,E12,F12,G12,H12";
                    }
                    else
                    {
                        tipsChannel.SelectedChannels = ichs.ToList();
                        tipsChannel.SetSelectedChannels();
                        tipsChannel_SelectedChangedEvent(null, null);
                    }

                    tbxWellPositionTips.Text = wellarray;
                    wellPlate.Selection = wellarray;
                    //wellPlate.SetSelection(wellarray);
                    tbxWellvolume.Text = wellvolume.ToString();

                    if (enableSingleWellvolume)
                    {
                        cbSingleVolumn.IsChecked = true;
                    }
                    else
                    {
                        cbSingleVolumn.IsChecked = false;
                    }

                    cbLiquidType.SelectedValue = liquididValue;
                    cbLiquidRange.SelectedValue = liquidrangeidValue;
                    cbLiquid.SelectedValue = liquidpidValue;

                    if (bMix)
                    {
                        checkboxMix.IsChecked = true;

                        tbxMixVolume.Text = mixvolume.ToString();
                        tbxMixCount.Text = mixcount.ToString();

                        cbMixAspiratePosition.SelectedIndex = mixAspiratePositionValue;
                        tbxMixAspirateDistance.Text = mixAspirateDistance.ToString();
                        tbxMixAspirateSpeed.Text = mixAspirateSpeed.ToString();

                        cbMixDispensePosition.SelectedIndex = mixDispensePositionValue;
                        tbxMixDispenseDistance.Text = mixDispenseDistance.ToString();
                        tbxMixDispenseSpeed.Text = mixDispenseSpeed.ToString();
                    }
                    else
                    {
                        checkboxMix.IsChecked = false;
                    }

                    if (enableLiquidSensor)
                    {
                        checkboxLiquidDetect.IsChecked = true;
                        gdLiquidSensor.IsEnabled = true;
                        txtNameLiquidSensorCount.Text = liquidSensorCount.ToString();
                        txtLiquidSensorDistance.Text = liquidSensorDistance.ToString();
                        txtLiquidSensorEndDistance.Text= liquidSensorEndDistance.ToString();
                        txtLiquidSensorSpeed.Text = liquidSensorSpeed.ToString();
                        txtLiquidSensorRadio.Text = liquidSensorRadio.ToString();
                        cbxLiquidSensorDisId.SelectedIndex = Convert.ToInt32(liquidSensorDisIdValue);
                        if(enableLiquidFollow)
                        {
                            checkboxLiquidFollow.IsChecked= true;
                            cbxLiquidFollowType.SelectedIndex = liquidFollowType;
                            txtLiquidFollowSpeed.Text = liquidFollowSpeed.ToString();
                            txtLiquidFollowDistance.Text= liquidFollowDistance.ToString();
                            if(liquidFollowType==1)
                            {
                                bdrFollowOneType.Visibility = Visibility.Visible;
                                tbkFollowTwoTypeLabel.Visibility = Visibility.Collapsed;
                                txtLiquidFollowArea.Visibility = Visibility.Collapsed;
                                tbkFollowTwoTypeUnit.Visibility = Visibility.Collapsed;
                                if (methodAspirate != null)
                                {
                                    methodAspirate.liquidFollowType = cbxLiquidFollowType.SelectedIndex;
                                    methodAspirate.liquidFollowTypeName = cbxLiquidFollowType.Text;
                                }
                            }
                            else if(liquidFollowType == 2)
                            {
                                bdrFollowOneType.Visibility = Visibility.Collapsed;
                                tbkFollowTwoTypeLabel.Visibility = Visibility.Visible;
                                txtLiquidFollowArea.Visibility = Visibility.Visible;
                                tbkFollowTwoTypeUnit.Visibility = Visibility.Visible;
                                if (methodAspirate != null)
                                {
                                    methodAspirate.liquidFollowType = cbxLiquidFollowType.SelectedIndex;
                                    methodAspirate.liquidFollowTypeName = cbxLiquidFollowType.Text;
                                }
                                txtLiquidFollowArea.Text = liquidFollowArea.ToString();
                            }
                            
                            if(enableMixFollow)
                            {
                                rdMixFollow.IsChecked = true;
                            }
                            else
                            {
                                rdMixNotFollow.IsChecked= true;
                            }
                        }
                        else
                        {
                            checkboxLiquidFollow.IsChecked = false;
                            cbxLiquidFollowType.SelectedIndex = liquidFollowType;
                            txtLiquidFollowSpeed.Text = liquidFollowSpeed.ToString();
                            txtLiquidFollowDistance.Text = liquidFollowDistance.ToString();
                            txtLiquidFollowArea.Text = liquidFollowArea.ToString();
                            //gdLiquidFollow.IsEnabled = false;
                            if (enableMixFollow)
                            {
                                rdMixFollow.IsChecked = true;
                            }
                            else
                            {
                                rdMixNotFollow.IsChecked = true;
                            }
                        }
                    }
                    else
                    {
                        checkboxLiquidDetect.IsChecked = false;
                        gdLiquidSensor.IsEnabled = false;
                        checkboxLiquidFollow.IsEnabled= false;
                        cbxLiquidSensorDisId.SelectedIndex = 0;
                        cbxLiquidSensorBlockDisId.SelectedIndex = 0;
                        cbxAspirateBlockDealType.SelectedIndex = 0;
                        cbxAspirateAirDealType.SelectedIndex = 0;
                        //gdLiquidFollow.IsEnabled = false;
                        cbxLiquidFollowType.SelectedIndex = liquidFollowType;
                        txtLiquidFollowSpeed.Text = liquidFollowSpeed.ToString();
                        txtLiquidFollowDistance.Text = liquidFollowDistance.ToString();
                        txtLiquidFollowArea.Text = liquidFollowArea.ToString();
                        if (enableMixFollow)
                        {
                            rdMixFollow.IsChecked = true;
                        }
                        else
                        {
                            rdMixNotFollow.IsChecked = true;
                        }
                    }

                    if (enableSensorBlock)
                    {
                        checkboxBlockDetect.IsChecked = true;
                        cbxAspirateBlockDealType.SelectedIndex = Convert.ToInt32(aspirateBlockDisIdValue);
                        gdBlockSensor.IsEnabled = true;
                    }
                    else
                    {
                        checkboxBlockDetect.IsChecked = false;
                        gdBlockSensor.IsEnabled = false;
                    }

                    cbxAspirateAirDealType.SelectedIndex = Convert.ToInt32(aspirateAirDisIdValue);
                    if (currmethodAspirate != null)
                    {
                        methodAspirate = currmethodAspirate;
                    }
                }
                else
                {
                    cbArm.SelectedIndex = curArmSelectedIndex;
                    if (cbArm.Items.Count > 1)
                    {
                        cbArm.SelectedIndex = 1;
                    }
                    DeviceArm arm = cbArm.SelectedItem as DeviceArm;
                    tbxHeadType.Text = arm.head_type;
                    cbLiquidType.SelectedIndex = curLiquidTypeSelectedIndex;
                    //cbLiquidRange.SelectedIndex = curLiquidRangeSelectedIndex;
                    cbMixAspiratePosition.SelectedIndex = curMixAspirateSelectIndex;
                    cbMixDispensePosition.SelectedIndex = curMixDispenseSelectIndex;
                    if (currmethodAspirate != null)
                    {
                        methodAspirate = currmethodAspirate;
                    }
                    cbxLiquidSensorDisId.SelectedIndex = 0;
                    cbxLiquidSensorBlockDisId.SelectedIndex = 0;
                    cbxAspirateBlockDealType.SelectedIndex = 0;
                    cbxAspirateAirDealType.SelectedIndex = 0;
                }
                ReceiveAndUpdate();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        #region 单孔编辑按钮事件
        private void btnSingleVolumnSetting_Click(object sender, RoutedEventArgs e)
        {
            if (EventResponseController.Instance.CanExecute() == false)
                return;

            Window wnd = Application.Current.MainWindow;
            Grid grid = Utilities.FindVisualChild<Grid>(wnd);

            VolumnSettingPerWell vspw = new VolumnSettingPerWell();
            vspw.closeEvent += Vspw_closeEvent;
            vspw.currentChannels = tipsChannel.SelectedChannels;
            if (!string.IsNullOrEmpty(methodAspirate.armText))
            {
                vspw.singleChannelValues = methodAspirate.singlewellvolume;
            }
            vspw.aspirateProperty = this;
            grid.Children.Add(vspw);
        }
        #endregion

        private void Vspw_closeEvent(object sender, EventArgs e)
        {
            Window wnd = Application.Current.MainWindow;
            Grid grid = Utilities.FindVisualChild<Grid>(wnd);

            UIElement element = sender as UIElement;
            grid.Children.Remove(element);
        }

        #region 设置某些属性信息值
        public void SetTableName(string tableName, Labware lb)
        {
            try
            {
                if (lb == null)
                    return;
                if (string.IsNullOrEmpty(lb.labware_id))
                    return;
                selectedLabware = lb;
                wellPlate.Rows = lb.number_row;
                wellPlate.Columns = lb.number_column;
                wellPlate.labwareWellInfoList = lb.labwareWellInfoList;
                wellPlate.LabwareRealWidth = lb.labware_length;
                wellPlate.LabwareRealLength = lb.labware_width;
                wellPlate.DataContext = lb;

                List<Lattice> latticeList = DataRWDAL.LatticeDB.GetLatticeDataFromdb(Shared.SoftwareInformation.software_device_number, Convert.ToInt32(methodAspirate.armValue));
                Lattice lattice = latticeList.Find(s => s.lattice_num == tableName);
                if (lattice == null)
                {
                    LoggerHelper.InfoLog("Error: Can't find lattice with lattice_num=" + tableName);
                    return;
                }
                comboboxTablePos.SelectedItem = tableName;
                if (Shared.ChannelCount.Equals(96))
                {
                    if (!lb.labware_type_id.Equals("3"))
                    {
                        if (!lb.number_row.Equals(8) || !lb.number_column.Equals(12))
                        {
                            ShowTip.ShowNotice("请选择96孔板的台面", InfoType.Warning);
                            tbxWellPositionTips.Text = "";
                            wellPlate.Selection = "";
                            return;
                        }
                    }
                    else
                    {
                        if (!lb.number_row.Equals(1) || !lb.number_column.Equals(1))
                        {
                            ShowTip.ShowNotice("请选择单试剂槽的台面", InfoType.Warning);
                            tbxWellPositionTips.Text = "";
                            wellPlate.Selection = "";
                            return;
                        }
                    }
                }
                if(lb.labware_tubeshelf_type.Equals(1))//异形管架耗材
                {
                    tbxWellPositionTips.Text = "";
                    wellPlate.Selection = "";
                }
                if (methodAspirate != null)
                {
                    methodAspirate.positionText = tableName;
                    methodAspirate.positionValue = lattice.lattice_id;
                    methodAspirate.labwareText = lb.labware_name;
                    methodAspirate.labwareValue = lb.labware_id;

                    if (Shared.ChannelCount.Equals(96))
                    {
                        if (!lb.labware_type_id.Equals("3"))
                        {
                            wellarray = "A1,B1,C1,D1,E1,F1,G1,H1,A2,B2,C2,D2,E2,F2,G2,H2,A3,B3,C3,D3,E3,F3,G3,H3,A4,B4,C4,D4,E4,F4,G4,H4,A5,B5,C5,D5,E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8,A9,B9,C9,D9,E9,F9,G9,H9,A10,B10,C10,D10,E10,F10,G10,H10,A11,B11,C11,D11,E11,F11,G11,H11,A12,B12,C12,D12,E12,F12,G12,H12";
                        }
                        else
                        {
                            wellarray = "A1";
                        }
                        tbxWellPositionTips.Text = wellarray;
                        wellPlate.Selection = wellarray;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        private void WellPlate_SelectedEvent(object sender, CustomRoutedEventArgs<string> e)
        {
            string str = (string)e.param;
            methodAspirate.wellarray = str;
        }

        private void cbArm_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                DeviceArm arm = cbArm.SelectedItem as DeviceArm;
                methodAspirate.armText = arm.device_arm_name;
                methodAspirate.armValue = arm.device_arm_id.ToString();
                methodAspirate.headType = arm.head_type;
                tbxHeadType.Text = arm.head_type.ToString();
                if (arm.arm_type.Equals(0))
                {
                    grid.RowDefinitions[3].Height = new GridLength(0);
                    grid.RowDefinitions[4].Height = new GridLength(0);
                    return;
                }
                else
                {
                    grid.RowDefinitions[3].Height = new GridLength(40);
                    grid.RowDefinitions[4].Height = new GridLength(80);
                }
                if (Shared.ChannelCount.Equals(96))
                {
                    curArmSelectedIndex = cbArm.SelectedIndex;
                    methodAspirate.channels = new int[] {1,2,3,4,5,6,7,8,
                                                            9,10,11,12,13,14,15,16,
                                                            17,18,19,20,21,22,23,24,
                                                            25,26,27,28,29,30,31,32,
                                                            33,34,35,36,37,38,39,40,
                                                            41,42,43,44,45,46,47,48,
                                                            49,50,51,52,53,54,55,56,
                                                            57,58,59,60,61,62,63,64,
                                                            65,66,67,68,69,70,71,72,
                                                            73,74,75,76,77,78,79,80,
                                                            81,82,83,84,85,86,87,88,
                                                            89,90,91,92,93,94,95,96};
                }
                else
                {
                    // 臂未选择
                    if (cbArm.SelectedIndex < 0 || cbArm.SelectedIndex == 0)
                    {
                        tipsChannel.SetTotalChannelCount(0);
                        tipsChannel.SelectedChannels = new List<int>();
                        tipsChannel.SetSelectedChannels();
                        tipsChannel_SelectedChangedEvent(null, null);
                        return;
                    }

                    curArmSelectedIndex = cbArm.SelectedIndex;
                    string armName = ((DeviceArm)cbArm.SelectedItem).device_arm_name.ToString();

                    tipsChannel.SelectedChannels = Shared.ChannelsId.ToList();
                    tipsChannel.SetTotalChannelCount(Shared.ChannelCount);
                    tipsChannel.SetSelectedChannels();
                    tipsChannel_SelectedChangedEvent(null, null);
                }
                ReceiveAndUpdate();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbLiquidType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbLiquidType.SelectedIndex < 0)
                return;
            if (cbLiquidType.SelectedIndex == 0)
            {
                cbLiquidRange.SelectedIndex = 0;
                cbLiquid.SelectedIndex = 0;
            }
            curLiquidTypeSelectedIndex = cbLiquidType.SelectedIndex;
            if (cbLiquidType.SelectedIndex != 0)
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquididText = ((LiquidType)cbLiquidType.SelectedItem).liquid_type_name.ToString();
                    methodAspirate.liquididValue = ((LiquidType)cbLiquidType.SelectedItem).liquid_type_id.ToString();
                }
            }
        }

        private void cbLiquidRange_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbLiquidRange.SelectedIndex < 0)
                return;
            curLiquidRangeSelectedIndex = cbLiquidRange.SelectedIndex;
            string typeID = cbLiquidType.SelectedValue as string;
            string rangeID = cbLiquidRange.SelectedValue as string;
            string armID = cbArm.SelectedValue.ToString();
            ObservableCollection<Liquid> liquidList = LiquidTypeRSRangeDB.GetLiquidFromdbByTypeAndRange(typeID, rangeID, armID);
            Liquid liquid = new Liquid();
            liquid.liquid_name = Properties.Resources.strPleaseSelect;
            liquidList.Insert(0, liquid);

            if (cbLiquidRange.SelectedIndex != 0)
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidrangeidText = ((LiquidRange)cbLiquidRange.SelectedItem).liquid_range_name.ToString();
                    methodAspirate.liquidrangeidValue = ((LiquidRange)cbLiquidRange.SelectedItem).liquid_range_id.ToString();
                }
            }

            cbLiquid.ItemsSource = liquidList;
            cbLiquid.SelectedIndex = 0;
        }

        private void cbLiquid_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbLiquid.SelectedIndex < 1)
                return;
            curLiquidSelectedIndex = cbLiquid.SelectedIndex;
            Liquid liquid = cbLiquid.SelectedItem as Liquid;
            if (cbLiquid.SelectedIndex != 0)
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidpidText = liquid.liquid_name;
                    methodAspirate.liquidpidValue = liquid.liquid_id;
                }
            }
        }

        private void cbMixAspiratePosition_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbMixAspiratePosition.SelectedIndex < 0)
                return;
            curMixAspirateSelectIndex = cbMixAspiratePosition.SelectedIndex;
            MixPositionEnum position = (MixPositionEnum)Enum.Parse(typeof(MixPositionEnum), (string)cbMixAspiratePosition.SelectedItem);
            if (methodAspirate != null)
            {
                methodAspirate.mixAspiratePositionValue = (int)position;
                if ((int)position == 0)
                {
                    methodAspirate.mixAspiratePositionText = "Liquid";
                }
                else if ((int)position == 1)
                {
                    methodAspirate.mixAspiratePositionText = "Top";
                }
                else
                {
                    methodAspirate.mixAspiratePositionText = "Bottom";
                }
            }
        }

        private void cbMixDispensePosition_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbMixDispensePosition.SelectedIndex < 0)
                return;
            curMixDispenseSelectIndex = cbMixDispensePosition.SelectedIndex;
            MixPositionEnum position = (MixPositionEnum)Enum.Parse(typeof(MixPositionEnum), (string)cbMixDispensePosition.SelectedItem);
            if (methodAspirate != null)
            {
                methodAspirate.mixDispensePositionValue = (int)position;
                if ((int)position == 0)
                {
                    methodAspirate.mixDispensePositionText = "Liquid";
                }
                else if ((int)position == 1)
                {
                    methodAspirate.mixDispensePositionText = "Top";
                }
                else
                {
                    methodAspirate.mixDispensePositionText = "Bottom";
                }
            }
        }

        #region 启用混合
        private void checkboxMix_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if ((bool)checkboxMix.IsChecked)
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.bMix = true;
                        methodAspirate.mixcount = Convert.ToInt32(tbxMixCount.Text);
                        methodAspirate.mixvolume = Convert.ToDouble(tbxMixVolume.Text);
                        methodAspirate.mixAspiratePositionText = cbMixAspiratePosition.Text;
                        methodAspirate.mixAspiratePositionValue = Convert.ToInt32(cbMixAspiratePosition.SelectedValue);
                        methodAspirate.mixAspirateDistance = Convert.ToDouble(tbxMixAspirateDistance.Text);
                        methodAspirate.mixAspirateSpeed = Convert.ToDouble(tbxMixAspirateSpeed.Text);

                        methodAspirate.mixDispensePositionText = cbMixDispensePosition.Text;
                        methodAspirate.mixDispensePositionValue = Convert.ToInt32(cbMixDispensePosition.SelectedValue);
                        methodAspirate.mixDispenseDistance = Convert.ToDouble(tbxMixDispenseDistance.Text);
                        methodAspirate.mixDispenseSpeed = Convert.ToDouble(tbxMixDispenseSpeed.Text);
                    }
                }
                else
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.bMix = false;
                        methodAspirate.mixcount = Convert.ToInt32(tbxMixCount.Text);
                        methodAspirate.mixvolume = Convert.ToDouble(tbxMixVolume.Text);
                        methodAspirate.mixAspiratePositionText = cbMixAspiratePosition.Text;
                        methodAspirate.mixAspiratePositionValue = Convert.ToInt32(cbMixAspiratePosition.SelectedValue);
                        methodAspirate.mixAspirateDistance = Convert.ToDouble(tbxMixAspirateDistance.Text);
                        methodAspirate.mixAspirateSpeed = Convert.ToDouble(tbxMixAspirateSpeed.Text);

                        methodAspirate.mixDispensePositionText = cbMixDispensePosition.Text;
                        methodAspirate.mixDispensePositionValue = Convert.ToInt32(cbMixDispensePosition.SelectedValue);
                        methodAspirate.mixDispenseDistance = Convert.ToDouble(tbxMixDispenseDistance.Text);
                        methodAspirate.mixDispenseSpeed = Convert.ToDouble(tbxMixDispenseSpeed.Text);
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        private void checkboxLiquidDetect_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if ((bool)checkboxLiquidDetect.IsChecked)
                {
                    checkboxLiquidFollow.IsEnabled = true;
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableLiquidSensor = true;
                        methodAspirate.liquidSensorCount = Convert.ToInt32(txtNameLiquidSensorCount.Text);
                        methodAspirate.liquidSensorDistance = Convert.ToDouble(txtLiquidSensorDistance.Text);
                        methodAspirate.liquidSensorEndDistance = Convert.ToDouble(txtLiquidSensorEndDistance.Text);
                        methodAspirate.liquidSensorSpeed = Convert.ToDouble(txtLiquidSensorSpeed.Text);
                        methodAspirate.liquidSensorRadio = Convert.ToDouble(txtLiquidSensorRadio.Text);
                        methodAspirate.liquidSensorDisIdText = cbxLiquidSensorDisId.Text;
                        methodAspirate.liquidSensorDisIdValue = Convert.ToDouble(cbxLiquidSensorDisId.SelectedIndex);
                        gdLiquidSensor.IsEnabled = true;
                    }
                }
                else
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableLiquidSensor = false;
                        methodAspirate.liquidSensorCount = Convert.ToInt32(txtNameLiquidSensorCount.Text);
                        methodAspirate.liquidSensorDistance = Convert.ToDouble(txtLiquidSensorDistance.Text);
                        methodAspirate.liquidSensorEndDistance = Convert.ToDouble(txtLiquidSensorEndDistance.Text);
                        methodAspirate.liquidSensorSpeed = Convert.ToDouble(txtLiquidSensorSpeed.Text);
                        methodAspirate.liquidSensorRadio = Convert.ToDouble(txtLiquidSensorRadio.Text);
                        methodAspirate.liquidSensorDisIdText = cbxLiquidSensorDisId.Text;
                        methodAspirate.liquidSensorDisIdValue = Convert.ToDouble(cbxLiquidSensorDisId.SelectedIndex);
                        methodAspirate.enableLiquidFollow = false;
                        gdLiquidSensor.IsEnabled = false;
                        //gdLiquidFollow.IsEnabled = false;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void txtNameLiquidSensorCount_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (!Consumables.ConsumablesValidationRule.IsPositiveIntegerr(txtNameLiquidSensorCount.Text, out string message))
                {
                    lscError.Text = message;
                    return;
                }
                else
                {
                    lscError.Text = "";
                }

                if (methodAspirate != null)
                {
                    methodAspirate.liquidSensorCount = Convert.ToInt32(txtNameLiquidSensorCount.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void txtLiquidSensorDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                string message = "";
                if (!Consumables.ConsumablesValidationRule.IsNullOrEmpty(txtLiquidSensorDistance.Text, out message) || !Consumables.ConsumablesValidationRule.IsPositiveNumber(txtLiquidSensorDistance.Text, out message))
                {
                    lsdError.Text = message;
                }
                else
                {
                    lsdError.Text = "";
                }
                //if (!Consumables.ConsumablesValidationRule.IsRange(txtLiquidSensorDistance.Text, 0.0, 100, false, out string message))
                //{
                //    lsdError.Text = message;
                //    return;
                //}
                //else
                //{
                //    lsdError.Text = "";
                //}
                if (methodAspirate != null)
                {
                    methodAspirate.liquidSensorDistance = Convert.ToDouble(txtLiquidSensorDistance.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbxLiquidSensorDisId_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidSensorDisIdText = ((string)cbxLiquidSensorDisId.SelectedItem).ToString();
                    methodAspirate.liquidSensorDisIdValue = Convert.ToDouble(cbxLiquidSensorDisId.SelectedIndex);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void checkboxBlockDetect_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if ((bool)checkboxBlockDetect.IsChecked)
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableSensorBlock = true;
                        methodAspirate.aspirateBlockDisIdText = cbxAspirateBlockDealType.Text;
                        methodAspirate.aspirateBlockDisIdValue = Convert.ToInt32(cbxAspirateBlockDealType.SelectedValue);
                        gdBlockSensor.IsEnabled = true;
                    }
                }
                else
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableSensorBlock = false;
                        methodAspirate.aspirateBlockDisIdText = cbxAspirateBlockDealType.Text;
                        methodAspirate.aspirateBlockDisIdValue = Convert.ToInt32(cbxAspirateBlockDealType.SelectedValue);
                        gdBlockSensor.IsEnabled = false;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxLiquidSensorBlockDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (!Consumables.ConsumablesValidationRule.IsRange(tbxLiquidSensorBlockDistance.Text, 0.0, 100, false, out string message))
                {
                    lsbdError.Text = message;
                    return;
                }
                else
                {
                    lsbdError.Text = "";
                }
                if (methodAspirate != null)
                {
                    //methodAspirate.liquidSensorBlockDistance = Convert.ToDouble(tbxLiquidSensorBlockDistance.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbxLiquidSensorBlockDisId_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    //methodAspirate.liquidSensorBlockDisIdText = cbxLiquidSensorBlockDisId.Text;
                    //methodAspirate.liquidSensorBlockDisIdValue = Convert.ToDouble(cbxLiquidSensorBlockDisId.SelectedValue);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxMixVolume_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (Shared.SoftwareInformation.software_device_number != DeviceCategory.DeviceHXFX)
                {
                    if (!Consumables.ConsumablesValidationRule.IsRange(tbxMixVolume.Text, 1.0, 1000.0, false, out string message))
                    {
                        tbxMixVolume.BorderBrush = Brushes.Red;
                        tbxMixVolume.BorderThickness = new Thickness(1);
                    }
                    else
                    {
                        tbxMixVolume.BorderBrush = Brushes.Black;
                    }
                }
                else
                {
                    if (!Consumables.ConsumablesValidationRule.IsRange(tbxMixVolume.Text, 1.0, 50000.0, false, out string message))
                    {
                        tbxMixVolume.BorderBrush = Brushes.Red;
                        tbxMixVolume.BorderThickness = new Thickness(1);
                    }
                    else
                    {
                        tbxMixVolume.BorderBrush = Brushes.Black;
                    }
                }
                if (methodAspirate != null)
                {
                    methodAspirate.mixvolume = Convert.ToDouble(tbxMixVolume.Text);
                    //validationMixVolume();
                }
            }
            catch (Exception ex)
            {
                //tbxMixVolume.BorderBrush = Brushes.Red;
                //tbkErrorMixVolume.Text = "[0,1000]";
                //tbkErrorMixVolume.Foreground = Brushes.Red;
                //tbkErrorMixVolume.Visibility = Visibility.Visible;
                LoggerHelper.ErrorLog("ERROR:", ex);
                return;
            }
        }

        public void validationMixVolume()
        {
            string volumeString = tbxMixVolume.Text;
            Regex rg = new Regex(@"^[1-9]\\d*.\\d*|0\\.\\d*[1-9]\\d*$");
            if (string.IsNullOrEmpty(volumeString))
            {
                tbxMixVolume.BorderBrush = Brushes.Red;
                tbkErrorMixVolume.Text = "[0,1000]";
                tbkErrorMixVolume.Foreground = Brushes.Red;
                tbkErrorMixVolume.Visibility = Visibility.Visible;
                return;
            }
            else if (rg.IsMatch(volumeString))
            {
                tbxMixVolume.BorderBrush = Brushes.Red;
                tbkErrorMixVolume.Text = "[0,1000]";
                tbkErrorMixVolume.Foreground = Brushes.Red;
                tbkErrorMixVolume.Visibility = Visibility.Visible;
                return;
            }
            else if (Convert.ToDouble(volumeString) < 0 || Convert.ToDouble(volumeString) > 1000)
            {
                tbxMixVolume.BorderBrush = Brushes.Red;
                tbkErrorMixVolume.Text = "[0,1000]";
                tbkErrorMixVolume.Foreground = Brushes.Red;
                tbkErrorMixVolume.Visibility = Visibility.Visible;
                return;
            }
            else
            {
                tbxMixVolume.BorderBrush = Brushes.Transparent;
                tbkErrorMixVolume.Foreground = Brushes.Transparent;
                tbkErrorMixVolume.Visibility = Visibility.Hidden;
            }
        }

        private void tbxMixCount_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.mixcount = Convert.ToInt32(tbxMixCount.Text);
                    validationMixCount();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                tbxMixCount.BorderBrush = Brushes.Red;
                tbkErrorMixCount.Text = "[0,1000]";
                tbkErrorMixCount.Foreground = Brushes.Red;
                tbkErrorMixCount.Visibility = Visibility.Visible;
                return;
            }
        }

        public void validationMixCount()
        {
            string volumeString = tbxMixVolume.Text;
            Regex rg = new Regex(@"^[1-9]\\d*.\\d*|0\\.\\d*[1-9]\\d*$");
            if (string.IsNullOrEmpty(volumeString))
            {
                tbxMixCount.BorderBrush = Brushes.Red;
                tbkErrorMixCount.Text = "[0,1000]";
                tbkErrorMixCount.Foreground = Brushes.Red;
                tbkErrorMixCount.Visibility = Visibility.Visible;
                return;
            }
            else if (rg.IsMatch(volumeString))
            {
                tbxMixCount.BorderBrush = Brushes.Red;
                tbkErrorMixCount.Text = "[0,1000]";
                tbkErrorMixCount.Foreground = Brushes.Red;
                tbkErrorMixCount.Visibility = Visibility.Visible;
                return;
            }
            else if (Convert.ToDouble(volumeString) < 0 || Convert.ToDouble(volumeString) > 1000)
            {
                tbxMixCount.BorderBrush = Brushes.Red;
                tbkErrorMixCount.Text = "[0,1000]";
                tbkErrorMixCount.Foreground = Brushes.Red;
                tbkErrorMixCount.Visibility = Visibility.Visible;
                return;
            }
            else
            {
                tbxMixCount.BorderBrush = Brushes.Transparent;
                tbkErrorMixCount.Foreground = Brushes.Transparent;
                tbkErrorMixCount.Visibility = Visibility.Hidden;
            }
        }

        private void tbxMixAspirateDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.mixAspirateDistance = Convert.ToDouble(tbxMixAspirateDistance.Text);
                    //if(methodAspirate.mixAspiratePositionText.Equals("Top"))
                    //{
                    if (string.IsNullOrEmpty(tbxMixAspirateDistance.Text))
                    {
                        tbxMixAspirateDistance.BorderBrush = Brushes.Red;
                        tbxMixAspirateDistance.BorderThickness = new Thickness(1);
                        tbkErrorMixAspirateDistance.Text = "[0,50]";
                        tbkErrorMixAspirateDistance.Foreground = Brushes.Red;
                        tbkErrorMixAspirateDistance.Visibility = Visibility.Visible;
                        return;
                    }
                    else if (Convert.ToDouble(tbxMixAspirateDistance.Text) < 0 || Convert.ToDouble(tbxMixAspirateDistance.Text) > 50)
                    {
                        tbxMixAspirateDistance.BorderBrush = Brushes.Red;
                        tbxMixAspirateDistance.BorderThickness = new Thickness(1);
                        tbkErrorMixAspirateDistance.Text = "[0,50]";
                        tbkErrorMixAspirateDistance.Foreground = Brushes.Red;
                        tbkErrorMixAspirateDistance.Visibility = Visibility.Visible;
                        return;
                    }
                    else
                    {
                        tbxMixAspirateDistance.BorderBrush = Brushes.Transparent;
                        tbxMixAspirateDistance.BorderThickness = new Thickness(0);
                        tbkErrorMixAspirateDistance.Foreground = Brushes.Red;
                        tbkErrorMixAspirateDistance.Visibility = Visibility.Hidden;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                tbxMixAspirateDistance.BorderBrush = Brushes.Red;
                tbxMixAspirateDistance.BorderThickness = new Thickness(1);
                return;
            }
        }

        private void tbxMixAspirateSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.mixAspirateSpeed = Convert.ToDouble(tbxMixAspirateSpeed.Text);
                    validationMixAspirateSpeed();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                tbxMixAspirateSpeed.BorderBrush = Brushes.Red;
                tbkErrorMixAspirateSpeed.Text = "[1,100]";
                tbkErrorMixAspirateSpeed.Foreground = Brushes.Red;
                tbkErrorMixAspirateSpeed.Visibility = Visibility.Visible;
                return;
            }
        }
        public void validationMixAspirateSpeed()
        {
            string volumeString = tbxMixAspirateSpeed.Text;
            Regex rg = new Regex(@"^[1-9]\\d*.\\d*|0\\.\\d*[1-9]\\d*$");
            if (string.IsNullOrEmpty(volumeString))
            {
                tbxMixAspirateSpeed.BorderBrush = Brushes.Red;
                tbkErrorMixAspirateSpeed.Text = "[1,100]";
                tbkErrorMixAspirateSpeed.Foreground = Brushes.Red;
                tbkErrorMixAspirateSpeed.Visibility = Visibility.Visible;
                return;
            }
            else if (rg.IsMatch(volumeString))
            {
                tbxMixAspirateSpeed.BorderBrush = Brushes.Red;
                tbkErrorMixAspirateSpeed.Text = "[1,100]";
                tbkErrorMixAspirateSpeed.Foreground = Brushes.Red;
                tbkErrorMixAspirateSpeed.Visibility = Visibility.Visible;
                return;
            }
            else if (Convert.ToDouble(volumeString) < 0 || Convert.ToDouble(volumeString) > 100)
            {
                tbxMixAspirateSpeed.BorderBrush = Brushes.Red;
                tbkErrorMixAspirateSpeed.Text = "[1,100]";
                tbkErrorMixAspirateSpeed.Foreground = Brushes.Red;
                tbkErrorMixAspirateSpeed.Visibility = Visibility.Visible;
                return;
            }
            else
            {
                tbxMixAspirateSpeed.BorderBrush = Brushes.Transparent;
                tbkErrorMixAspirateSpeed.Foreground = Brushes.Transparent;
                tbkErrorMixAspirateSpeed.Visibility = Visibility.Hidden;
            }
        }

        private void tbxMixDispenseDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.mixDispenseDistance = Convert.ToDouble(tbxMixDispenseDistance.Text);
                    if (string.IsNullOrEmpty(tbxMixDispenseDistance.Text))
                    {
                        tbxMixDispenseDistance.BorderBrush = Brushes.Red;
                        tbxMixDispenseDistance.BorderThickness = new Thickness(1);
                        tbkErrorMixDispenseDistance.Text = "[0,50]";
                        tbkErrorMixDispenseDistance.Foreground = Brushes.Red;
                        tbkErrorMixDispenseDistance.Visibility = Visibility.Visible;
                        return;
                    }
                    else if (Convert.ToDouble(tbxMixDispenseDistance.Text) < 0 || Convert.ToDouble(tbxMixDispenseDistance.Text) > 50)
                    {
                        tbxMixDispenseDistance.BorderBrush = Brushes.Red;
                        tbxMixDispenseDistance.BorderThickness = new Thickness(1);
                        tbkErrorMixDispenseDistance.Text = "[0,50]";
                        tbkErrorMixDispenseDistance.Foreground = Brushes.Red;
                        tbkErrorMixDispenseDistance.Visibility = Visibility.Visible;
                        return;
                    }
                    else
                    {
                        tbxMixDispenseDistance.BorderBrush = Brushes.Transparent;
                        tbxMixDispenseDistance.BorderThickness = new Thickness(0);
                        tbkErrorMixDispenseDistance.Foreground = Brushes.Red;
                        tbkErrorMixDispenseDistance.Visibility = Visibility.Hidden;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                tbxMixDispenseDistance.BorderBrush = Brushes.Red;
                tbxMixDispenseDistance.BorderThickness = new Thickness(1);
                return;
            }
        }

        private void tbxMixDispenseSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.mixDispenseSpeed = Convert.ToDouble(tbxMixDispenseSpeed.Text);
                    validationMixDispenseSpeed(tbxMixDispenseSpeed, tbkErrorMixDispenseSpeed);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                tbxMixDispenseSpeed.BorderBrush = Brushes.Red;
                tbkErrorMixDispenseSpeed.Text = "[1,100]";
                tbkErrorMixDispenseSpeed.Foreground = Brushes.Red;
                tbkErrorMixDispenseSpeed.Visibility = Visibility.Visible;
                return;
            }
        }

        public void validationMixDispenseSpeed(TextBox textBoxObj,TextBlock textBlockObj)
        {
            string volumeString = textBoxObj.Text;
            Regex rg = new Regex(@"^[1-9]\\d*.\\d*|0\\.\\d*[1-9]\\d*$");
            if (string.IsNullOrEmpty(volumeString))
            {
                textBoxObj.BorderBrush = Brushes.Red;
                textBlockObj.Text = "[1,100]";
                textBlockObj.Foreground = Brushes.Red;
                textBlockObj.Visibility = Visibility.Visible;
                return;
            }
            else if (rg.IsMatch(volumeString))
            {
                textBoxObj.BorderBrush = Brushes.Red;
                textBlockObj.Text = "[1,100]";
                textBlockObj.Foreground = Brushes.Red;
                textBlockObj.Visibility = Visibility.Visible;
                return;
            }
            else if (Convert.ToDouble(volumeString) < 0 || Convert.ToDouble(volumeString) > 100)
            {
                textBoxObj.BorderBrush = Brushes.Red;
                textBlockObj.Text = "[1,100]";
                textBlockObj.Foreground = Brushes.Red;
                textBlockObj.Visibility = Visibility.Visible;
                return;
            }
            else
            {
                textBoxObj.BorderBrush = Brushes.Transparent;
                textBlockObj.Foreground = Brushes.Transparent;
                textBlockObj.Visibility = Visibility.Hidden;
            }
        }

        private void cbSingleVolumn_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (cbSingleVolumn.IsChecked == true)
                {
                    btnSingleVolumnSetting.Foreground = new SolidColorBrush(Colors.Blue);
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableSingleWellvolume = true;
                    }
                }
                else
                {
                    btnSingleVolumnSetting.Foreground = new SolidColorBrush(Colors.Black);
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableSingleWellvolume = false;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxWellPositionTips_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.wellarray = tbxWellPositionTips.Text;
                    if (Shared.ChannelCount.Equals(96))
                    {
                        methodAspirate.channels = new int[] {1,2,3,4,5,6,7,8,
                                                            9,10,11,12,13,14,15,16,
                                                            17,18,19,20,21,22,23,24,
                                                            25,26,27,28,29,30,31,32,
                                                            33,34,35,36,37,38,39,40,
                                                            41,42,43,44,45,46,47,48,
                                                            49,50,51,52,53,54,55,56,
                                                            57,58,59,60,61,62,63,64,
                                                            65,66,67,68,69,70,71,72,
                                                            73,74,75,76,77,78,79,80,
                                                            81,82,83,84,85,86,87,88,
                                                            89,90,91,92,93,94,95,96};
                    }
                    else
                    {
                        methodAspirate.channels = tipsChannel.SelectedChannels.ToArray();
                    }
                    validationWellPosition();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                tbxWellPositionTips.BorderBrush = Brushes.Red;
                tbxWellPositionTips.BorderThickness = new Thickness(1);
                tbkErrorWellPosition.Text = "请先选择孔位,例如：A1,B1";
                tbkErrorWellPosition.Foreground = Brushes.Red;
                tbkErrorWellPosition.Visibility = Visibility.Visible;
                return;
            }
        }

        public void validationWellPosition()
        {
            string wellString = tbxWellPositionTips.Text;
            if (string.IsNullOrEmpty(wellString))
            {
                tbxWellPositionTips.BorderBrush = Brushes.Red;
                tbxWellPositionTips.BorderThickness = new Thickness(1);
                tbkErrorWellPosition.Text = "请先选择孔位";
                tbkErrorWellPosition.Foreground = Brushes.Red;
                tbkErrorWellPosition.Visibility = Visibility.Visible;
                return;
            }
            else if (wellString.Contains("=") && !wellString.Substring(0, 1).Equals("="))
            {
                tbxWellPositionTips.BorderBrush = Brushes.Red;
                tbxWellPositionTips.BorderThickness = new Thickness(1);
                tbkErrorWellPosition.Text = "输入的孔位，包含“=”时，格式应为：=i,i为命令前设置的变量名称";
                tbkErrorWellPosition.TextWrapping = TextWrapping.WrapWithOverflow;
                tbkErrorWellPosition.Foreground = Brushes.Red;
                tbkErrorWellPosition.Visibility = Visibility.Visible;
                return;
            }
            else if (wellString.Contains("&") && !wellString.Substring(0, 1).Equals("&"))
            {
                tbxWellPositionTips.BorderBrush = Brushes.Red;
                tbxWellPositionTips.BorderThickness = new Thickness(1);
                tbkErrorWellPosition.Text = "输入的孔位，包含“&”时，格式应为：&i,i为命令前设置的变量名称";
                tbkErrorWellPosition.TextWrapping = TextWrapping.WrapWithOverflow;
                tbkErrorWellPosition.Foreground = Brushes.Red;
                tbkErrorWellPosition.Visibility = Visibility.Visible;
                return;
            }
            else if (wellString.Contains(";") || wellString.Contains("|") ||
                     wellString.Contains("*") || wellString.Contains("!") ||
                     wellString.Contains("@") || wellString.Contains("#") ||
                     wellString.Contains("$") || wellString.Contains("%") ||
                     wellString.Contains("^") || wellString.Contains("(") ||
                     wellString.Contains(")") || wellString.Contains("{") ||
                     wellString.Contains("}") || wellString.Contains("[") ||
                     wellString.Contains("]") || wellString.Contains("?") ||
                     wellString.Contains("/") || wellString.Contains("\\") ||
                     wellString.Contains("~") || wellString.Contains("`") ||
                     wellString.Contains(":") || wellString.Contains("\"") ||
                     wellString.Contains("'"))
            {
                tbxWellPositionTips.BorderBrush = Brushes.Red;
                tbxWellPositionTips.BorderThickness = new Thickness(1);
                tbkErrorWellPosition.Text = "输入的孔位，不能包含“;”、“|”、“*”、“!”、“@”、“#”、“$”、“%”、" +
                                                   "“^”、“(”、“)”、“{”、“}”、“[”、“]”、“?”、“/”、“\\”、“~”、" +
                                                   "“`”、“:”、“\"”、“'”";
                tbkErrorWellPosition.TextWrapping = TextWrapping.WrapWithOverflow;
                tbkErrorWellPosition.Foreground = Brushes.Red;
                tbkErrorWellPosition.Visibility = Visibility.Visible;
                return;
            }
            else
            {
                tbxWellPositionTips.BorderBrush = Brushes.Transparent;
                tbxWellPositionTips.BorderThickness = new Thickness(0);
                tbkErrorWellPosition.Foreground = Brushes.Transparent;
                tbkErrorWellPosition.Visibility = Visibility.Hidden;
            }
        }

        private void tbxCommandLabel_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {

                if (methodAspirate != null)
                {
                    methodAspirate.label = tbxCommandLabel.Text;
                    methodAspirate.name = tbxCommandName.Text.ToString();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxWellvolume_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (Shared.SoftwareInformation.software_device_number != DeviceCategory.DeviceHXFX)
                {
                    if (!Consumables.ConsumablesValidationRule.IsRange(tbxWellvolume.Text, 1.0, 1000.0, false, out string message))
                    {
                        tbxWellvolume.BorderBrush = Brushes.Red;
                        tbkErrorWellVolume.Text = message;
                        tbkErrorWellVolume.Foreground = Brushes.Red;
                        tbkErrorWellVolume.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        tbxWellvolume.BorderBrush = Brushes.Black;
                        tbkErrorWellVolume.Text = "";
                    }
                }
                else
                {
                    if (!Consumables.ConsumablesValidationRule.IsRange(tbxWellvolume.Text, 1.0, 100000.0, false, out string message))
                    {
                        tbxWellvolume.BorderBrush = Brushes.Red;
                        tbkErrorWellVolume.Text = message;
                        tbkErrorWellVolume.Foreground = Brushes.Red;
                        tbkErrorWellVolume.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        tbxWellvolume.BorderBrush = Brushes.Black;
                        tbkErrorWellVolume.Text = "";
                    }
                }

                if (methodAspirate != null)
                {
                    methodAspirate.wellvolume = Convert.ToDouble(tbxWellvolume.Text);
                    //validationWellVolume();

                    if (this.method != null)
                    {
                        this.method.method_Tipcontent = string.Format("{0};{1}", methodAspirate.positionText, methodAspirate.wellvolume);
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                tbxWellvolume.BorderBrush = Brushes.Red;
                tbkErrorWellVolume.Text = "每孔体积值：[1,1000]之间";
                tbkErrorWellVolume.Foreground = Brushes.Red;
                tbkErrorWellVolume.Visibility = Visibility.Visible;
                return;
            }
        }

        public void validationWellVolume()
        {
            string volumeString = tbxWellvolume.Text;
            Regex rg = new Regex(@"^[1-9]\\d*.\\d*|0\\.\\d*[1-9]\\d*$");
            if (string.IsNullOrEmpty(volumeString))
            {
                tbxWellvolume.BorderBrush = Brushes.Red;
                tbkErrorWellVolume.Text = "每孔体积值：[0,1000]之间";
                tbkErrorWellVolume.Foreground = Brushes.Red;
                tbkErrorWellVolume.Visibility = Visibility.Visible;
                return;
            }
            else if (rg.IsMatch(volumeString))
            {
                tbxWellvolume.BorderBrush = Brushes.Red;
                tbkErrorWellVolume.Text = "每孔体积值：[0,1000]之间";
                tbkErrorWellVolume.Foreground = Brushes.Red;
                tbkErrorWellVolume.Visibility = Visibility.Visible;
                return;
            }
            else if (Convert.ToDouble(volumeString) < 0 || Convert.ToDouble(volumeString) > 1000)
            {
                tbxWellvolume.BorderBrush = Brushes.Red;
                tbkErrorWellVolume.Text = "[0,1000]之间";
                tbkErrorWellVolume.Foreground = Brushes.Red;
                tbkErrorWellVolume.Visibility = Visibility.Visible;
                return;
            }
            else
            {
                tbxWellvolume.BorderBrush = Brushes.Transparent;
                tbkErrorWellVolume.Foreground = Brushes.Transparent;
                tbkErrorWellVolume.Visibility = Visibility.Hidden;
            }
        }

        private void tbxCommandName_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.name = tbxCommandName.Text;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void comboboxTablePos_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (comboboxTablePos.SelectedItem == null)
                    return;
                string name = comboboxTablePos.SelectedItem as string;
                SetTableName(name, selectedLabware);

                #region 验证台面耗材类型
                if (TestDesign.SelectLabwares.Count() <= 0 || TestDesign.SelectLabwares.FirstOrDefault(m => m.Label.Equals(comboboxTablePos.SelectedValue.ToString())) == null)
                    return;

                ControlLabware labware = TestDesign.SelectLabwares.FirstOrDefault(m => m.Label.Equals(comboboxTablePos.SelectedValue.ToString()));
                if ("1,3,5,4".Contains(labware.LabwareType.ToString()))
                {
                    cmbTablePos.Text = "";
                }
                else
                {
                    cmbTablePos.Text = $"不能在耗材 [{labware.LabwareName}] 执行吸液";
                }
                #endregion

                if (this.method != null)
                {
                    this.method.method_Tipcontent = string.Format("{0};{1}", methodAspirate.positionText,methodAspirate.wellvolume);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 刷新液体下拉
        /// </summary>
        /// <param name="liquid_id">需要删除的液体ID</param>
        /// <param name="IsDelete">是否删除</param>
        private void BindLiquids(string liquid_id, bool IsDelete)
        {
            if (IsDelete)
            {
                //记录所选值
                string id = cbLiquid.SelectedValue.ToString();
                int index = cbLiquid.SelectedIndex;

                //刷新下拉数据
                cbLiquidRange_SelectionChanged(null, null);

                //删除的液体是所需液体
                if (id.Equals(liquid_id))
                    //重置为请选择
                    cbLiquid.SelectedIndex = 0;
                else
                    //保持之前选择
                    cbLiquid.SelectedIndex = index;
            }
            else
            {
                //记录所选值
                int index = cbLiquid.SelectedIndex;
                //刷新下拉数据
                cbLiquidRange_SelectionChanged(null, null);
                //保持之前选择
                cbLiquid.SelectedIndex = index;
            }
        }

        #region 可用通道鼠标选择变更事件
        /// <summary>
        /// 可用通道鼠标选择变更事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tipsChannel_SelectedChangedEvent(object sender, EventArgs e)
        {
            methodAspirate.channels = tipsChannel.SelectedChannels.ToArray();
        }
        #endregion

        private void checkboxLiquidFollow_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if(checkboxLiquidDetect.IsChecked==false)
                {
                    checkboxLiquidFollow.IsChecked = false;
                    return;
                }

                if(checkboxLiquidFollow.IsChecked==true)
                {
                    if (Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceX3)
                    {
                        cbxLiquidFollowType.SelectedIndex = 2;
                    }
                    else
                    {
                        cbxLiquidFollowType.SelectedIndex = 1;
                    }
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableLiquidFollow = true;
                        methodAspirate.liquidFollowType = Convert.ToInt32(cbxLiquidFollowType.SelectedIndex);
                        methodAspirate.liquidFollowTypeName = cbxLiquidFollowType.Text;
                        methodAspirate.liquidFollowSpeed = Convert.ToDouble(txtLiquidFollowSpeed.Text);
                        methodAspirate.liquidFollowDistance = Convert.ToDouble(txtLiquidFollowDistance.Text);
                        methodAspirate.liquidFollowArea = Convert.ToDouble(txtLiquidFollowArea.Text);
                        methodAspirate.enableMixFollow = rdMixFollow.IsChecked == true ? true:false;
                        methodAspirate.liquidSensorDisIdText = cbxLiquidSensorDisId.Text;
                        methodAspirate.liquidSensorDisIdValue = Convert.ToDouble(cbxLiquidSensorDisId.SelectedIndex);
                        //gdLiquidFollow.IsEnabled = true;
                    }
                }
                else
                {
                    if (Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceX3)
                    {
                        cbxLiquidFollowType.SelectedIndex = 2;
                    }
                    else
                    {
                        cbxLiquidFollowType.SelectedIndex = 1;
                    }
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableLiquidFollow = false;
                        methodAspirate.liquidFollowType = Convert.ToInt32(cbxLiquidFollowType.SelectedIndex);
                        methodAspirate.liquidFollowTypeName = cbxLiquidFollowType.Text;
                        methodAspirate.liquidFollowSpeed = Convert.ToDouble(txtLiquidFollowSpeed.Text);
                        methodAspirate.liquidFollowDistance = Convert.ToDouble(txtLiquidFollowDistance.Text);
                        methodAspirate.liquidFollowArea = Convert.ToDouble(txtLiquidFollowArea.Text);
                        methodAspirate.enableMixFollow = rdMixFollow.IsChecked == true ? true : false;
                        methodAspirate.liquidSensorDisIdText = cbxLiquidSensorDisId.Text;
                        methodAspirate.liquidSensorDisIdValue = Convert.ToDouble(cbxLiquidSensorDisId.SelectedIndex);
                        //gdLiquidFollow.IsEnabled = false;
                    }
                }
            }
            catch (Exception ex)
            {

            }
        }

        private void txtLiquidSensorEndDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidSensorEndDistance = Convert.ToDouble(txtLiquidSensorEndDistance.Text);

                    if (string.IsNullOrEmpty(txtLiquidSensorEndDistance.Text))
                    {
                        txtLiquidSensorEndDistance.BorderBrush = Brushes.Red;
                        txtLiquidSensorEndDistance.BorderThickness = new Thickness(1);
                        tbkErrorLiquidSensorEndDistance.Text = "[0,50]";
                        tbkErrorLiquidSensorEndDistance.Foreground = Brushes.Red;
                        tbkErrorLiquidSensorEndDistance.Visibility = Visibility.Visible;
                        return;
                    }
                    else if (Convert.ToDouble(txtLiquidSensorEndDistance.Text) < 0 || Convert.ToDouble(txtLiquidSensorEndDistance.Text) > 50)
                    {
                        txtLiquidSensorEndDistance.BorderBrush = Brushes.Red;
                        txtLiquidSensorEndDistance.BorderThickness = new Thickness(1);
                        tbkErrorLiquidSensorEndDistance.Text = "[0,50]";
                        tbkErrorLiquidSensorEndDistance.Foreground = Brushes.Red;
                        tbkErrorLiquidSensorEndDistance.Visibility = Visibility.Visible;
                        return;
                    }
                    else
                    {
                        txtLiquidSensorEndDistance.BorderBrush = Brushes.Transparent;
                        txtLiquidSensorEndDistance.BorderThickness = new Thickness(0);
                        tbkErrorLiquidSensorEndDistance.Foreground = Brushes.Red;
                        tbkErrorLiquidSensorEndDistance.Visibility = Visibility.Hidden;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                txtLiquidSensorEndDistance.BorderBrush = Brushes.Red;
                txtLiquidSensorEndDistance.BorderThickness = new Thickness(1);
                return;
            }
        }

        private void txtLiquidSensorSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidSensorSpeed = Convert.ToDouble(txtLiquidSensorSpeed.Text);
                    validationMixDispenseSpeed(txtLiquidSensorSpeed, tbkErrorLiquidSensorSpeed);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                txtLiquidSensorSpeed.BorderBrush = Brushes.Red;
                tbkErrorLiquidSensorSpeed.Text = "[1,100]";
                tbkErrorLiquidSensorSpeed.Foreground = Brushes.Red;
                tbkErrorLiquidSensorSpeed.Visibility = Visibility.Visible;
                return;
            }
        }

        private void txtLiquidSensorRadio_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidSensorRadio = Convert.ToDouble(txtLiquidSensorRadio.Text);
                    if (string.IsNullOrEmpty(txtLiquidSensorRadio.Text))
                    {
                        txtLiquidSensorRadio.BorderBrush = Brushes.Red;
                        txtLiquidSensorRadio.BorderThickness = new Thickness(1);
                        tbkErrorLiquidSensorRadio.Text = "[0,100]";
                        tbkErrorLiquidSensorRadio.Foreground = Brushes.Red;
                        tbkErrorLiquidSensorRadio.Visibility = Visibility.Visible;
                        return;
                    }
                    else if (Convert.ToDouble(txtLiquidSensorRadio.Text) < 0 || Convert.ToDouble(txtLiquidSensorRadio.Text) > 100)
                    {
                        txtLiquidSensorRadio.BorderBrush = Brushes.Red;
                        txtLiquidSensorRadio.BorderThickness = new Thickness(1);
                        tbkErrorLiquidSensorRadio.Text = "[0,100]";
                        tbkErrorLiquidSensorRadio.Foreground = Brushes.Red;
                        tbkErrorLiquidSensorRadio.Visibility = Visibility.Visible;
                        return;
                    }
                    else
                    {
                        txtLiquidSensorRadio.BorderBrush = Brushes.Transparent;
                        txtLiquidSensorRadio.BorderThickness = new Thickness(0);
                        tbkErrorLiquidSensorRadio.Foreground = Brushes.Red;
                        tbkErrorLiquidSensorRadio.Visibility = Visibility.Hidden;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                txtLiquidSensorRadio.BorderBrush = Brushes.Red;
                txtLiquidSensorRadio.BorderThickness = new Thickness(1);
                return;
            }
        }

        private void cbxLiquidFollowType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbxLiquidFollowType.SelectedIndex == 1)
                {
                    bdrFollowOneType.Visibility = Visibility.Visible;
                    tbkFollowTwoTypeLabel.Visibility = Visibility.Collapsed;
                    txtLiquidFollowArea.Visibility = Visibility.Collapsed;
                    tbkFollowTwoTypeUnit.Visibility = Visibility.Collapsed;
                    if (methodAspirate != null)
                    {
                        methodAspirate.liquidFollowType = cbxLiquidFollowType.SelectedIndex;
                        methodAspirate.liquidFollowTypeName = ((string)cbxLiquidFollowType.SelectedItem).ToString();
                    }
                }
                else if (cbxLiquidFollowType.SelectedIndex == 2)
                {
                    bdrFollowOneType.Visibility = Visibility.Collapsed;
                    tbkFollowTwoTypeLabel.Visibility = Visibility.Visible;
                    txtLiquidFollowArea.Visibility = Visibility.Visible;
                    tbkFollowTwoTypeUnit.Visibility = Visibility.Visible;
                    if (methodAspirate != null)
                    {
                        methodAspirate.liquidFollowType = cbxLiquidFollowType.SelectedIndex;
                        methodAspirate.liquidFollowTypeName = ((string)cbxLiquidFollowType.SelectedItem).ToString();
                    }
                }
            }
            catch(Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void txtLiquidFollowDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidFollowDistance = Convert.ToDouble(txtLiquidFollowDistance.Text);
                    //if(methodAspirate.mixAspiratePositionText.Equals("Top"))
                    //{
                    if (string.IsNullOrEmpty(txtLiquidFollowDistance.Text))
                    {
                        txtLiquidFollowDistance.BorderBrush = Brushes.Red;
                        txtLiquidFollowDistance.BorderThickness = new Thickness(1);
                        tbkErrorLiquidFollowDistance.Text = "[0,50]";
                        tbkErrorLiquidFollowDistance.Foreground = Brushes.Red;
                        tbkErrorLiquidFollowDistance.Visibility = Visibility.Visible;
                        return;
                    }
                    else if (Convert.ToDouble(txtLiquidFollowDistance.Text) < 0 || Convert.ToDouble(txtLiquidFollowDistance.Text) > 50)
                    {
                        txtLiquidFollowDistance.BorderBrush = Brushes.Red;
                        txtLiquidFollowDistance.BorderThickness = new Thickness(1);
                        tbkErrorLiquidFollowDistance.Text = "[0,50]";
                        tbkErrorLiquidFollowDistance.Foreground = Brushes.Red;
                        tbkErrorLiquidFollowDistance.Visibility = Visibility.Visible;
                        return;
                    }
                    else
                    {
                        txtLiquidFollowDistance.BorderBrush = Brushes.Transparent;
                        txtLiquidFollowDistance.BorderThickness = new Thickness(0);
                        tbkErrorLiquidFollowDistance.Foreground = Brushes.Red;
                        tbkErrorLiquidFollowDistance.Visibility = Visibility.Hidden;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                txtLiquidFollowDistance.BorderBrush = Brushes.Red;
                txtLiquidFollowDistance.BorderThickness = new Thickness(1);
                return;
            }
        }

        private void txtLiquidFollowSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidFollowSpeed = Convert.ToDouble(txtLiquidFollowSpeed.Text);
                    validationMixDispenseSpeed(txtLiquidFollowSpeed, tbkErrorLiquidFollowSpeed);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                txtLiquidFollowSpeed.BorderBrush = Brushes.Red;
                tbkErrorLiquidFollowSpeed.Text = "[1,100]";
                tbkErrorLiquidFollowSpeed.Foreground = Brushes.Red;
                tbkErrorLiquidFollowSpeed.Visibility = Visibility.Visible;
                return;
            }
        }

        private void txtLiquidFollowArea_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.liquidFollowArea = Convert.ToDouble(txtLiquidSensorRadio.Text);
                    //if(methodAspirate.mixAspiratePositionText.Equals("Top"))
                    //{
                    if (string.IsNullOrEmpty(txtLiquidSensorRadio.Text))
                    {
                        txtLiquidSensorRadio.BorderBrush = Brushes.Red;
                        txtLiquidSensorRadio.BorderThickness = new Thickness(1);
                        tbkErrorLiquidFollowArea.Text = "[0,30000]";
                        tbkErrorLiquidFollowArea.Foreground = Brushes.Red;
                        tbkErrorLiquidFollowArea.Visibility = Visibility.Visible;
                        return;
                    }
                    else if (Convert.ToDouble(txtLiquidSensorRadio.Text) < 0 || Convert.ToDouble(txtLiquidSensorRadio.Text) > 30000)
                    {
                        txtLiquidSensorRadio.BorderBrush = Brushes.Red;
                        txtLiquidSensorRadio.BorderThickness = new Thickness(1);
                        tbkErrorLiquidFollowArea.Text = "[0,30000]";
                        tbkErrorLiquidFollowArea.Foreground = Brushes.Red;
                        tbkErrorLiquidFollowArea.Visibility = Visibility.Visible;
                        return;
                    }
                    else
                    {
                        txtLiquidSensorRadio.BorderBrush = Brushes.Transparent;
                        txtLiquidSensorRadio.BorderThickness = new Thickness(0);
                        tbkErrorLiquidFollowArea.Foreground = Brushes.Red;
                        tbkErrorLiquidFollowArea.Visibility = Visibility.Hidden;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                txtLiquidSensorRadio.BorderBrush = Brushes.Red;
                txtLiquidSensorRadio.BorderThickness = new Thickness(1);
                return;
            }
        }

        private void rdMixFollow_Checked(object sender, RoutedEventArgs e)
        {
            try
            {

                if (rdMixFollow.IsChecked == true)
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableMixFollow = true;
                    }
                }
                else
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableMixFollow = false;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                return;
            }
        }

        private void rdMixNotFollow_Checked(object sender, RoutedEventArgs e)
        {
            try
            {

                if (rdMixNotFollow.IsChecked == true)
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableMixFollow = false;
                    }
                }
                else
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.enableMixFollow = true;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
                return;
            }
        }

        private void checkboxMultiMix_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if ((bool)checkboxMultiMix.IsChecked)
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.bMultiMix = true;
                    }
                }
                else
                {
                    if (methodAspirate != null)
                    {
                        methodAspirate.bMultiMix = false;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbxAspirateBlockDealType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.aspirateBlockDisIdText = ((string)cbxAspirateBlockDealType.SelectedItem).ToString();
                    methodAspirate.aspirateBlockDisIdValue = cbxAspirateBlockDealType.SelectedIndex;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

        }

        private void cbxAspirateAirDealType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (methodAspirate != null)
                {
                    methodAspirate.aspirateAirDisIdText = ((string)cbxAspirateAirDealType.SelectedItem).ToString();
                    methodAspirate.aspirateAirDisIdValue = cbxAspirateAirDealType.SelectedIndex;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void wellPlate_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            try
            {
                tbxWellPositionTips.Text = wellPlate.Selection;
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
    }
}