using DataEntity.Share;
using DataRWDAL;
using DataRWDalDrive.DB;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using XCommon.Log;
using XCore;
using XHandler.Class;
using XHandler.Class.DataEx;
using XImagingXhandler.XDAL;
using XHandler.View.Consumables;
using System.Windows.Media;
using System.Text.RegularExpressions;
using System.Linq;
using XHandler.Controls;

namespace XHandler.View.MethodProperty
{
    /// <summary>
    /// FileProperty.xaml 的交互逻辑
    /// </summary>
    public partial class FileProperty : UserControl, IMethodProperty,IConsumableObserver,IDeviceArmObserver
    {
        TransferFileBll transferFileBll = new TransferFileBll();

        public MethodTransferFile methodTransferFile { get; set; }
        public MethodTransferFile currmethodTransferFile = null;

        #region 全局属性变量
        string isrun = "";
        string status = "";
        string name = "";
        string label = "";
        string armText = "";
        string armValue = "";
        string labwaretipText = "";
        string labwaretipValue = "";
        int[] channels = new int[0] { };

        string filePath = "";
        int beginLine = 0;
        DataTable transferDataTable = new DataTable();
        string sourceLabware = "";
        string sourceWell = "";
        string destinationLabware = "";
        string destinationWell = "";
        string destVolume = "";
        string tipSet = "";
        int changeTipsMode = 0;
        string changeToTipText = "";
        int changeToTipValue = 0;
        bool jump0Volume = false;

        string liquididText = "";
        string liquididValue = "";
        string liquidrangeidText = "";
        string liquidrangeidValue = "";
        string liquidpidText = "";
        string liquidpidValue = "";
        bool bMix = 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 = 0.0d;
        double liquidSensorRadio = 0.0d;
        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 dispenseBlockDisIdText = "";
        int dispenseBlockDisIdValue = 0;
        string aspirateAirDisIdText = "";
        int aspirateAirDisIdValue = 0;

        int mark = 0;
        #endregion

        private Labware selectedLabware = null;
        int curArmSelectedIndex = -1;

        public FileProperty()
        {
            InitializeComponent();
        }

        bool isConsumableUpdate = false;
        /// <summary>
        /// 耗材变更后，更新节点
        /// </summary>
        /// <param name="consumableManagement">耗材管理对象</param>
        public void ReceiveAndUpdate(ConsumableManagement consumableManagement)
        {
            isConsumableUpdate = true;
            ObservableCollection<Labware> tipsList = DataRWDAL.LabwareDB.GetTipLabwareFromdb();
            cbTipsType.ItemsSource = tipsList;
            cbTipsType.SelectedValue = methodTransferFile.labwaretipValue;
        }

        /// <summary>
        /// 通道设置变更后，更新节点
        /// </summary>
        /// <param name="testDesign"></param>
        public void ReceiveAndUpdate()
        {
            try
            {
                var a = cbArm.SelectedItem as DeviceArm;
                if(a.channels==0)
                {
                    return;
                }
                // 获取当前设备臂信息
                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 (methodTransferFile != null)
                {
                    methodTransferFile.channels = iChannels;
                }
            }
            catch(Exception ex)
            {
                LoggerHelper.ErrorLog("ReceiveAndUpdate error ", ex); 
            }
        }

        public FileProperty(MethodEx method)
        {
            InitializeComponent();
            mark = 0;
            methodTransferFile = new MethodTransferFile();
            methodTransferFile.label = method.method_name;
            methodTransferFile.name = method.method_name;
            methodTransferFile.status = (method.isEnabled == true ? "enable" : "disable");
            

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

            ObservableCollection<Labware> tipsList = DataRWDAL.LabwareDB.GetTipLabwareFromdb();
            cbTipsType.ItemsSource = tipsList;
            cbTipsType.SelectedIndex = 0;

            ObservableCollection<LiquidRange> liquidRangeList = DataModule.getInstance().GetLiquidRanges();
            cbLiquidRange.ItemsSource = liquidRangeList;
            //cbTipsType.ItemsSource = liquidRangeList;
            cbLiquidRange.SelectedIndex = 0;


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

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

            // 获取加液、取液位置类型
            ObservableCollection<DropdownName> mixPositionList = DataModule.getInstance().GetDispensePositionType();
            cbMixAspiratePosition.ItemsSource = mixPositionList;
            cbMixDispensePosition.ItemsSource = mixPositionList;

            cbMixAspiratePosition.SelectedIndex = 0;
            cbMixDispensePosition.SelectedIndex = 0;
            tbxCommandLabel.Text = method.method_name;
            checkboxSkip.IsChecked = true;

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

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

            ObservableCollection<string> listDispenseBlockProcess = DataModule.getInstance().GetDispenseBlockDealTypeList();
            cbxDispenseBlockDealType.ItemsSource = listDispenseBlockProcess;

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

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

            radioBtnNotChange.IsChecked = true;
            methodTransferFile.strIndex = method.strIndex;

            if (method.tag != null)
            {
                methodTransferFile = (MethodTransferFile)method.tag;

                currmethodTransferFile = methodTransferFile;

                isrun = methodTransferFile.isrun;
                status = methodTransferFile.status;
                name = methodTransferFile.name;
                label = methodTransferFile.label;
                armText = methodTransferFile.armText;
                armValue = methodTransferFile.armValue;
                labwaretipText = methodTransferFile.labwaretipText;
                labwaretipValue = methodTransferFile.labwaretipValue;
                channels = methodTransferFile.channels;

                filePath = methodTransferFile.filePath;
                beginLine = methodTransferFile.beginLine;
                transferDataTable = methodTransferFile.transferDataTable;
                sourceLabware = methodTransferFile.sourceLabware;
                sourceWell = methodTransferFile.sourceWell;
                destinationLabware = methodTransferFile.destinationLabware;
                destinationWell = methodTransferFile.destinationWell;
                destVolume = methodTransferFile.destVolume;
                tipSet = methodTransferFile.tipSet;
                changeTipsMode = methodTransferFile.changeTipsMode;
                changeToTipText = methodTransferFile.changeToTipText;
                changeToTipValue = methodTransferFile.changeToTipValue;
                jump0Volume = methodTransferFile.jump0Volume;

                liquididText = methodTransferFile.liquididText;
                liquididValue = methodTransferFile.liquididValue;
                liquidrangeidText = methodTransferFile.liquidrangeidText;
                liquidrangeidValue = methodTransferFile.liquidrangeidValue;
                liquidpidText = methodTransferFile.liquidpidText;
                liquidpidValue = methodTransferFile.liquidpidValue;
                bMix = methodTransferFile.bMix;
                mixvolume = methodTransferFile.mixvolume;
                mixcount = methodTransferFile.mixcount;
                mixAspiratePositionText = methodTransferFile.mixAspiratePositionText;
                mixAspiratePositionValue = methodTransferFile.mixAspiratePositionValue;
                mixAspirateDistance = methodTransferFile.mixAspirateDistance;
                mixAspirateSpeed = methodTransferFile.mixAspirateSpeed;
                mixDispensePositionText = methodTransferFile.mixDispensePositionText;
                mixDispensePositionValue = methodTransferFile.mixDispensePositionValue;
                mixDispenseDistance = methodTransferFile.mixDispenseDistance;
                mixDispenseSpeed = methodTransferFile.mixDispenseSpeed;

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

                enableSensorBlock = methodTransferFile.enableSensorBlock;
                //liquidSensorBlockDistance = methodTransferFile.liquidSensorBlockDistance;
                aspirateBlockDisIdText = methodTransferFile.aspirateBlockDisIdText;
                aspirateBlockDisIdValue = methodTransferFile.aspirateBlockDisIdValue;
                dispenseBlockDisIdText = methodTransferFile.dispenseBlockDisIdText;
                dispenseBlockDisIdValue = methodTransferFile.dispenseBlockDisIdValue;
                aspirateAirDisIdText = methodTransferFile.aspirateAirDisIdText;
                aspirateAirDisIdValue = methodTransferFile.aspirateAirDisIdValue;
            }
            this.DataContext = methodTransferFile;
        }

        public void SetTableName(string tableName, Labware lb)
        {
            if (lb == null)
                return;
            if (string.IsNullOrEmpty(lb.labware_id))
                return;
            if (string.IsNullOrEmpty(methodTransferFile.armValue))
            {
                MessageBox.Show(Properties.Resources.msgPlsSelectArm, "Tips");
                return;
            }
            selectedLabware = lb;

            List<Lattice> latticeList = DataRWDAL.LatticeDB.GetLatticeDataFromdb(Shared.SoftwareInformation.software_device_number, Convert.ToInt32(methodTransferFile.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;
            }
            if (methodTransferFile != null)
            {
                methodTransferFile.labwaretipText = lb.labware_name;
                methodTransferFile.labwaretipValue = lb.labware_id;
            }
            //tbSelectTable.Tag = lb.labware_id;
            //tbSelectTable.Text = lb.labware_name;
        }

        #region 选择文件
        /// <summary>
        /// 选择文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSelectFile_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.Title = "请选择Excel文件";
            dlg.FileName = string.Empty;
            dlg.FilterIndex = 1;
            dlg.Filter = "excel files(*.xls)|*.xls|csv files(*.csv)|*.csv|All files(*.*)|*.*";
            dlg.Multiselect = false;
            if (!string.IsNullOrEmpty(tbExcelFile.Text.Trim()))
            {
                try
                {
                    if (System.IO.Path.HasExtension(tbExcelFile.Text.Trim()))
                        dlg.InitialDirectory = System.IO.Path.GetDirectoryName(tbExcelFile.Text.Trim());
                    else
                        dlg.InitialDirectory = tbExcelFile.Text.Trim();
                }
                catch(Exception ex)
                {

                }
            }
            if (dlg.ShowDialog() == true)
            {
                string fullPath = dlg.FileName;
                if (methodTransferFile != null)
                {
                    methodTransferFile.filePath = fullPath;
                }
                tbExcelFile.Text = fullPath;

                SelectFile(fullPath);
            }
            
            ((MainWindow)Application.Current.MainWindow).testDesign.IsIgnore = true; //防止影响到主界面流程中已拖放的单命令顺序
        }

        private void tbExcelFile_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                if (!string.IsNullOrEmpty(tbExcelFile.Text.Trim()))
                {
                    if (System.IO.Path.HasExtension(tbExcelFile.Text.Trim()))
                    {
                        if (System.IO.File.Exists(tbExcelFile.Text.Trim()))
                        {
                            SelectFile(tbExcelFile.Text.Trim());
                        }
                    }
                }
            }
        }
        private void SelectFile(string file)
        {
            string ext = System.IO.Path.GetExtension(file);
            DataTable transferData = null;
            if (string.Compare(ext, ".csv", true) == 0)
                transferData = ExcelAndCsvHelper.GetDataTableFromCsvFile(file);
            else
                transferData = ExcelAndCsvHelper.GetDataTableFromExcelFile(file, true);

            if (transferData != null)
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.transferDataTable = transferData;
                }
                dgTransferFileData.ItemsSource = transferData.DefaultView;

                List<TransferFileHeader> transferFileHeaders = transferFileBll.GetTransferFileHeaders(transferData);

                cbSourceBoard.ItemsSource = transferFileHeaders;
                cbSourceWell.ItemsSource = transferFileHeaders;
                cbTargetBoard.ItemsSource = transferFileHeaders;
                cbTargetWell.ItemsSource = transferFileHeaders;
                cbVolumn.ItemsSource = transferFileHeaders;

                cbSourceBoard.SelectedIndex = 0;
                cbSourceWell.SelectedIndex = 0;
                cbTargetBoard.SelectedIndex = 0;
                cbTargetWell.SelectedIndex = 0;
                cbVolumn.SelectedIndex = 0;
            }
        }

        #endregion

        private void cbMixAspiratePosition_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (methodTransferFile != null)
            {
                methodTransferFile.mixAspiratePositionValue = Convert.ToInt32(cbMixAspiratePosition.SelectedValue);
            }
        }

        private void cbMixDispensePosition_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (methodTransferFile != null)
            {
                methodTransferFile.mixDispensePositionValue = Convert.ToInt32(cbMixDispensePosition.SelectedValue);
            }
        }

        private void cbArm_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbArm.SelectedIndex < 0)
                {
                    return;
                }
                curArmSelectedIndex = cbArm.SelectedIndex;
                string armName = ((DeviceArm)cbArm.SelectedItem).device_arm_name.ToString();
                methodTransferFile.channels = Shared.ChannelsId;
                DeviceArm arm = cbArm.SelectedItem as DeviceArm;
                methodTransferFile.armText = arm.device_arm_name;
                methodTransferFile.armValue = arm.device_arm_id.ToString();
                methodTransferFile.headType = arm.head_type;
                tbxHeadType.Text = arm.head_type.ToString();
                if (arm.arm_type.Equals(0))
                {
                    gridTipSetting.RowDefinitions[1].Height = new GridLength(0);
                    gridTipSetting.RowDefinitions[2].Height = new GridLength(0);
                    return;
                }
                else
                {
                    gridTipSetting.RowDefinitions[1].Height = new GridLength(40);
                    gridTipSetting.RowDefinitions[2].Height = new GridLength(80);
                }
                //if (tipsChannel.SelectedChannels.Count > 0)
                //{
                //    methodTransferFile.channels = tipsChannel.SelectedChannels.ToArray();
                //}
                if (cbArm.SelectedIndex != 1)
                {
                    tipsChannel.Visibility = Visibility.Collapsed;
                }
                else
                {
                    tipsChannel.SelectedChannels = Shared.ChannelsId.ToList();
                    tipsChannel.SetTotalChannelCount(Shared.ChannelCount);
                    tipsChannel.SetSelectedChannels();
                    tipsChannel_SelectedChangedEvent(null, null);
                    tipsChannel.Visibility = Visibility.Visible;
                }
                ReceiveAndUpdate();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbTipsType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (methodTransferFile == null) return;
            if (cbTipsType.SelectedIndex < 0) return;
            if (isConsumableUpdate)
            {
                isConsumableUpdate = false;
                return;
            }

            Labware labware = cbTipsType.SelectedItem as Labware;
            methodTransferFile.labwaretipText = labware.labware_name;
            methodTransferFile.labwaretipValue = labware.labware_id.ToString();
        }

        private void btnFinish_Click(object sender, RoutedEventArgs e)
        {
            stepBar.Next();
            scrollViewer.ScrollToTop();
        }

        private void btnNext_Click(object sender, RoutedEventArgs e)
        {
            stepBar.Next();
            gridSelectFile.Visibility = Visibility.Collapsed;
            gridTipSetting.Visibility = Visibility.Visible;
            gridLiquidParam.Visibility = Visibility.Collapsed;
            scrollViewer.ScrollToTop();
        }

        private void btnPrev_Click(object sender, RoutedEventArgs e)
        {
            stepBar.Prev();
            gridSelectFile.Visibility = Visibility.Visible;
            gridTipSetting.Visibility = Visibility.Collapsed;
            gridLiquidParam.Visibility = Visibility.Collapsed;
            scrollViewer.ScrollToTop();
        }

        private void btnPrev1_Click(object sender, RoutedEventArgs e)
        {
            if (stepBar.StepIndex > stepBar.Items.Count)
            {
                stepBar.Prev();
                stepBar.Prev();
            }
            else
                stepBar.Prev();
            gridSelectFile.Visibility = Visibility.Collapsed;
            gridTipSetting.Visibility = Visibility.Visible;
            gridLiquidParam.Visibility = Visibility.Collapsed;
            scrollViewer.ScrollToTop();
        }

        private void btnNext1_Click(object sender, RoutedEventArgs e)
        {
            stepBar.Next();
            gridSelectFile.Visibility = Visibility.Collapsed;
            gridTipSetting.Visibility = Visibility.Collapsed;
            gridLiquidParam.Visibility = Visibility.Visible;
            scrollViewer.ScrollToTop();
        }

        private void checkboxSkip_Checked(object sender, RoutedEventArgs e)
        {
            if (methodTransferFile == null)
                return;
            //if (checkboxSkip.IsChecked == true)
            methodTransferFile.jump0Volume = true;
        }

        private void radioBtnNotChange_Checked(object sender, RoutedEventArgs e)
        {
            if (radioBtnNotChange.IsChecked == true)
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.changeTipsMode = 0;
                }
            }
        }

        private void radioBtnChangeByFile_Checked(object sender, RoutedEventArgs e)
        {

            if (radioBtnChangeByFile.IsChecked == true)
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.changeTipsMode = 1;
                }
            }
        }

        private void radioBtnOperation_Checked(object sender, RoutedEventArgs e)
        {

            if (radioBtnOperation.IsChecked == true)
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.changeTipsMode = 2;
                }
            }
        }

        private void cbLiquidType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbLiquidType.SelectedIndex < 0)
                return;
            if (cbLiquidType.SelectedIndex == 0)
            {
                ObservableCollection<Liquid> liquids = new ObservableCollection<Liquid>();
                Liquid liquid = new Liquid();
                liquid.liquid_name = Properties.Resources.strPleaseSelect;
                liquids.Insert(0, liquid);
                cbLiquid.ItemsSource = liquids;
                cbLiquid.SelectedIndex = 0;
                return;
            }
            //if (cbLiquidRange.SelectedIndex <= 0)
            //    return;
            //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 l = new Liquid();
            //l.liquid_name = Properties.Resources.strPleaseSelect;
            //liquidList.Insert(0, l);

            if (cbLiquidType.SelectedIndex != 0)
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.liquididText = ((LiquidType)cbLiquidType.SelectedItem).liquid_type_name.ToString();
                    methodTransferFile.liquididValue = ((LiquidType)cbLiquidType.SelectedItem).liquid_type_id.ToString();
                }
            }
        }

        private void cbLiquidRange_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (cbLiquidRange.SelectedIndex < 0)
                return;
            if (cbLiquidRange.SelectedIndex == 0)
            {
                ObservableCollection<Liquid> liquids = new ObservableCollection<Liquid>();
                Liquid liquid = new Liquid();
                liquid.liquid_name = Properties.Resources.strPleaseSelect;
                liquids.Insert(0, liquid);
                cbLiquid.ItemsSource = liquids;
                cbLiquid.SelectedIndex = 0;
                return;
            }
            if (cbLiquidType.SelectedIndex <= 0)
                return;
            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 l = new Liquid();
            l.liquid_name = Properties.Resources.strPleaseSelect;
            liquidList.Insert(0, l);
            if (cbLiquidRange.SelectedIndex != 0)
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.liquidrangeidText = ((LiquidRange)cbLiquidRange.SelectedItem).liquid_range_name.ToString();
                    methodTransferFile.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 <= 0)
                return;
            Liquid l = cbLiquid.SelectedItem as Liquid;
            if (methodTransferFile != null)
            {
                methodTransferFile.liquidpidText = l.liquid_name;
                methodTransferFile.liquidpidValue = l.liquid_id;
            }
        }

        private 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;
                    //tbSelectTable.Tag = labwaretipValue;
                    //tbSelectTable.Text = labwaretipText;

                    tbxbeginLine.Text = beginLine.ToString();
                    cbTipsType.SelectedValue = labwaretipValue;

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

                    dgTransferFileData.ItemsSource = transferDataTable.DefaultView;
                    tbExcelFile.Text = filePath;

                    //更新所有下拉列表
                    List<TransferFileHeader> transferFileHeaders = transferFileBll.GetTransferFileHeaders(transferDataTable);

                    cbSourceBoard.ItemsSource = transferFileHeaders;

                    cbSourceWell.ItemsSource = transferFileHeaders;

                    cbTargetBoard.ItemsSource = transferFileHeaders;

                    cbTargetWell.ItemsSource = transferFileHeaders;

                    cbVolumn.ItemsSource = transferFileHeaders;

                    //cbVolumn.ItemsSource = transferFileHeaders;

                    //if (methodTransferFile.transferDataTable.Columns.Count >= 5)
                    //{
                    cbSourceBoard.Text = sourceLabware;
                    cbSourceWell.Text = sourceWell;
                    cbTargetBoard.SelectedValue = destinationLabware;
                    cbTargetWell.Text = destinationWell;
                    cbVolumn.Text = destVolume.ToString();
                    //cbTipsType.Text = tipSet;

                    if (changeTipsMode == 0)
                    {
                        radioBtnNotChange.IsChecked = true;
                    }
                    else if (changeTipsMode == 1)
                    {
                        radioBtnChangeByFile.IsChecked = true;
                    }
                    else if (changeTipsMode == 2)
                    {
                        radioBtnOperation.IsChecked = true;
                    }

                    if (jump0Volume)
                    {
                        checkboxSkip.IsChecked = true;
                    }
                    else
                    {
                        checkboxSkip.IsChecked = false;
                    }

                    if (bMix)
                    {
                        checkboxMix.IsChecked = true;

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

                        cbMixAspiratePosition.SelectedValue = mixAspiratePositionValue;

                        tbxMixAspirateDistance.Text = mixAspirateDistance.ToString();
                        tbxMixAspirateSpeed.Text = mixAspirateSpeed.ToString();

                        cbMixDispensePosition.SelectedValue = 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 (methodTransferFile != null)
                                {
                                    methodTransferFile.liquidFollowType = cbxLiquidFollowType.SelectedIndex;
                                    methodTransferFile.liquidFollowTypeName = cbxLiquidFollowType.Text;
                                }
                            }
                            else if (liquidFollowType == 2)
                            {
                                bdrFollowOneType.Visibility = Visibility.Collapsed;
                                tbkFollowTwoTypeLabel.Visibility = Visibility.Visible;
                                txtLiquidFollowArea.Visibility = Visibility.Visible;
                                tbkFollowTwoTypeUnit.Visibility = Visibility.Visible;
                                if (methodTransferFile != null)
                                {
                                    methodTransferFile.liquidFollowType = cbxLiquidFollowType.SelectedIndex;
                                    methodTransferFile.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;
                        cbxAspirateBlockDealType.SelectedIndex = 0;
                        cbxDispenseBlockDealType.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;
                        //tbxLiquidSensorBlockDistance.Text = liquidSensorBlockDistance.ToString();
                        cbxAspirateBlockDealType.SelectedIndex = Convert.ToInt32(aspirateBlockDisIdValue);
                        cbxDispenseBlockDealType.SelectedIndex = Convert.ToInt32(dispenseBlockDisIdValue);
                    }
                    else
                    {
                        checkboxBlockDetect.IsChecked = false;
                    }

                    cbxAspirateAirDealType.SelectedIndex = Convert.ToInt32(aspirateAirDisIdValue);

                    if (currmethodTransferFile != null)
                    {
                        methodTransferFile = currmethodTransferFile;
                    }
                }
                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 = 0;

                    cbMixAspiratePosition.SelectedIndex = 0;
                    cbMixDispensePosition.SelectedIndex = 0;
                    methodTransferFile.jump0Volume = true;
                    if (currmethodTransferFile != null)
                    {
                        methodTransferFile = currmethodTransferFile;
                    }

                    cbxLiquidSensorDisId.SelectedIndex = 0;
                    cbxAspirateBlockDealType.SelectedIndex = 0;
                    cbxDispenseBlockDealType.SelectedIndex = 0;
                    cbxAspirateAirDealType.SelectedIndex = 0;
                }

                ReceiveAndUpdate();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbSelectTable_TextChanged(object sender, TextChangedEventArgs e)
        {
        }

        private void tbxbeginLine_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.beginLine = Convert.ToInt32(tbxbeginLine.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbSourceBoard_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbSourceBoard.SelectedItem == null)
                    return;
                TransferFileHeader transferFileHeader = cbSourceBoard.SelectedItem as TransferFileHeader;
                if (methodTransferFile != null)
                {
                    methodTransferFile.sourceLabware = transferFileHeader.header_name.ToString();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbSourceWell_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbSourceWell.SelectedItem == null)
                    return;
                TransferFileHeader transferFileHeader = cbSourceWell.SelectedItem as TransferFileHeader;
                if (methodTransferFile != null)
                {
                    methodTransferFile.sourceWell = transferFileHeader.header_name;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbTargetBoard_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbTargetBoard.SelectedItem == null)
                    return;
                TransferFileHeader transferFileHeader = cbTargetBoard.SelectedItem as TransferFileHeader;
                if (methodTransferFile != null)
                {
                    methodTransferFile.destinationLabware = transferFileHeader.header_name;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbTargetWell_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbTargetWell.SelectedItem == null)
                    return;
                TransferFileHeader transferFileHeader = cbTargetWell.SelectedItem as TransferFileHeader;
                if (methodTransferFile != null)
                {
                    methodTransferFile.destinationWell = transferFileHeader.header_name;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbVolumn_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbVolumn.SelectedItem == null)
                    return;
                TransferFileHeader transferFileHeader = cbVolumn.SelectedItem as TransferFileHeader;
                if (methodTransferFile != null)
                {

                    methodTransferFile.destVolume = transferFileHeader.header_name;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void checkboxSkip_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (checkboxSkip.IsChecked == true)
                {
                    if (methodTransferFile != null)
                    {
                        methodTransferFile.jump0Volume = true;
                    }
                }
                else
                {
                    if (methodTransferFile != null)
                    {
                        methodTransferFile.jump0Volume = false;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

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

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

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

        private void tbxMixVolume_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.mixvolume = Convert.ToDouble(tbxMixVolume.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxMixCount_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.mixcount = Convert.ToInt32(tbxMixCount.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxMixAspirateDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.mixAspirateDistance = Convert.ToDouble(tbxMixAspirateDistance.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxMixAspirateSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.mixAspirateSpeed = Convert.ToDouble(tbxMixAspirateSpeed.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxMixDispenseDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.mixDispenseDistance = Convert.ToDouble(tbxMixDispenseDistance.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxMixDispenseSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.mixDispenseSpeed = Convert.ToDouble(tbxMixDispenseSpeed.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void tbxCommandName_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (string.IsNullOrEmpty(tbxCommandName.Text))
                {
                    cnError.Text = "命令名称不能为空";
                    return;
                }
                if (methodTransferFile != null)
                {
                    methodTransferFile.name = tbxCommandName.Text;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void comboboxTablePos_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {

        }

        private void txtNameLiquidSensorCount_TextChanged(object sender, TextChangedEventArgs e)
        {
            string message = "";
            if (!Consumables.ConsumablesValidationRule.IsNullOrEmpty(txtNameLiquidSensorCount.Text, out message) || !Consumables.ConsumablesValidationRule.IsIntegerr(txtNameLiquidSensorCount.Text, out message))
            {
                lscError.Text = message;
                return;
            }
            else
            {
                lscError.Text = "";
            }
            if (methodTransferFile != null)
            {
                methodTransferFile.liquidSensorCount = Convert.ToInt32(txtNameLiquidSensorCount.Text);
            }
        }

        private void txtLiquidSensorDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            string message = "";
            if (!Consumables.ConsumablesValidationRule.IsNullOrEmpty(txtLiquidSensorDistance.Text, out message) || !Consumables.ConsumablesValidationRule.IsPositiveNumber(txtLiquidSensorDistance.Text, out message))
            {
                lsdError.Text = message;
            }
            else
            {
                lsdError.Text = "";
            }
            if (methodTransferFile != null)
            {
                methodTransferFile.liquidSensorDistance = Convert.ToDouble(txtLiquidSensorDistance.Text);
            }
        }

        private void tbxLiquidSensorBlockDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            //string message = "";
            //if (!Consumables.ConsumablesValidationRule.IsNullOrEmpty(tbxLiquidSensorBlockDistance.Text, out message) || !Consumables.ConsumablesValidationRule.IsPositiveNumber(tbxLiquidSensorBlockDistance.Text, out message))
            //{
            //    lsbError.Text = message;
            //}
            //else
            //{
            //    lsbError.Text = "";
            //}
        }

        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 (methodTransferFile != null)
                    {
                        methodTransferFile.enableLiquidFollow = true;
                        methodTransferFile.liquidFollowType = Convert.ToInt32(cbxLiquidFollowType.SelectedIndex);
                        methodTransferFile.liquidFollowTypeName = cbxLiquidFollowType.Text;
                        methodTransferFile.liquidFollowSpeed = Convert.ToDouble(txtLiquidFollowSpeed.Text);
                        methodTransferFile.liquidFollowDistance = Convert.ToDouble(txtLiquidFollowDistance.Text);
                        methodTransferFile.liquidFollowArea = Convert.ToDouble(txtLiquidFollowArea.Text);
                        methodTransferFile.enableMixFollow = rdMixFollow.IsChecked == true ? true : false;
                        methodTransferFile.liquidSensorDisIdText = cbxLiquidSensorDisId.Text;
                        methodTransferFile.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 (methodTransferFile != null)
                    {
                        methodTransferFile.enableLiquidFollow = false;
                        methodTransferFile.liquidFollowType = Convert.ToInt32(cbxLiquidFollowType.SelectedIndex);
                        methodTransferFile.liquidFollowTypeName = cbxLiquidFollowType.Text;
                        methodTransferFile.liquidFollowSpeed = Convert.ToDouble(txtLiquidFollowSpeed.Text);
                        methodTransferFile.liquidFollowDistance = Convert.ToDouble(txtLiquidFollowDistance.Text);
                        methodTransferFile.liquidFollowArea = Convert.ToDouble(txtLiquidFollowArea.Text);
                        methodTransferFile.enableMixFollow = rdMixFollow.IsChecked == true ? true : false;
                        methodTransferFile.liquidSensorDisIdText = cbxLiquidSensorDisId.Text;
                        methodTransferFile.liquidSensorDisIdValue = Convert.ToDouble(cbxLiquidSensorDisId.SelectedIndex);
                        //gdLiquidFollow.IsEnabled = false;
                    }
                }
            }
            catch (Exception ex)
            {

            }
        }

        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 (methodTransferFile != null)
                    {
                        methodTransferFile.liquidFollowType = cbxLiquidFollowType.SelectedIndex;
                        methodTransferFile.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 (methodTransferFile != null)
                    {
                        methodTransferFile.liquidFollowType = cbxLiquidFollowType.SelectedIndex;
                        methodTransferFile.liquidFollowTypeName = ((string)cbxLiquidFollowType.SelectedItem).ToString();
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void txtLiquidFollowSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.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;
            }
        }

        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 rdMixFollow_Checked(object sender, RoutedEventArgs e)
        {
            try
            {

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

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

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

        private void txtLiquidFollowDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.liquidFollowDistance = Convert.ToDouble(txtLiquidFollowDistance.Text);

                    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 txtLiquidFollowArea_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.liquidFollowArea = Convert.ToDouble(txtLiquidFollowArea.Text);

                    if (string.IsNullOrEmpty(txtLiquidFollowArea.Text))
                    {
                        txtLiquidFollowArea.BorderBrush = Brushes.Red;
                        txtLiquidFollowArea.BorderThickness = new Thickness(1);
                        tbkErrorLiquidFollowArea.Text = "[0,30000]";
                        tbkErrorLiquidFollowArea.Foreground = Brushes.Red;
                        tbkErrorLiquidFollowArea.Visibility = Visibility.Visible;
                        return;
                    }
                    else if (Convert.ToDouble(txtLiquidFollowArea.Text) < 0 || Convert.ToDouble(txtLiquidFollowArea.Text) > 30000)
                    {
                        txtLiquidFollowArea.BorderBrush = Brushes.Red;
                        txtLiquidFollowArea.BorderThickness = new Thickness(1);
                        tbkErrorLiquidFollowArea.Text = "[0,30000]";
                        tbkErrorLiquidFollowArea.Foreground = Brushes.Red;
                        tbkErrorLiquidFollowArea.Visibility = Visibility.Visible;
                        return;
                    }
                    else
                    {
                        txtLiquidFollowArea.BorderBrush = Brushes.Transparent;
                        txtLiquidFollowArea.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 cbxLiquidSensorDisId_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.liquidSensorDisIdText = ((string)cbxLiquidSensorDisId.SelectedItem).ToString();
                    methodTransferFile.liquidSensorDisIdValue = Convert.ToDouble(cbxLiquidSensorDisId.SelectedIndex);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

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

        private void txtLiquidSensorEndDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.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 txtLiquidSensorRadio_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.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 txtLiquidSensorSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.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 tipsChannel_SelectedChangedEvent(object sender, EventArgs e)
        {
            methodTransferFile.channels = tipsChannel.SelectedChannels.ToArray();
        }

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

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

        private void cbxDispenseBlockDealType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (methodTransferFile != null)
                {
                    methodTransferFile.dispenseBlockDisIdText = ((string)cbxDispenseBlockDealType.SelectedItem).ToString(); 
                    methodTransferFile.dispenseBlockDisIdValue = cbxDispenseBlockDealType.SelectedIndex;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

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