using DataEntity.Share;
using DataRWDAL;
using DataRWDalDrive.DB;
using HxEnum;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using XCommon.Log;
using XHandler.Class.DataEx;
using XHandler.View.Dialog;
using XHandler.View.MethodProperty;
using XImagingXhandler.XDAL;
using XHandler.View.Liquids;
using XHandler.Controls;

namespace XHandler.View.BacteriaProperty
{
    /// <summary>
    /// 梯度稀释 属性页面
    /// </summary>
    public partial class DilutionProperty : UserControl, IMethodProperty,ILiquidObserver,ILatticeObserver
    {
        #region 变量
        public MethodDilution methodDilution = null;
        private int mark = 0;
        private int[] channels = Shared.ChannelsId;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public DilutionProperty(MethodEx method)
        {
            InitializeComponent();

            #region 臂
            // 获取机械臂信息
            List<DeviceArm> armList = DataModule.getInstance().GetDeviceArm();
            cbArm.ItemsSource = armList;
            #endregion

            #region 获取台面点位
            //List<Lattice> lattices = DataModule.getInstance().GetLattices(true);
            //lattices.Insert(0, new Lattice() { lattice_id = "-1", lattice_num = Properties.Resources.strPleaseSelect });
            //comboboxTablePos.ItemsSource = lattices;
            //comboboxTablePos.SelectedIndex = 0;

            //comboboxTablePosDilution.ItemsSource = lattices;
            //comboboxTablePosDilution.SelectedIndex = 0;
            #endregion

            #region 液体参数
            ObservableCollection<LiquidType> liquidTypeList = DataModule.getInstance().GetLiquidTypes();
            cbLiquidType.ItemsSource = cbLiquidTypeDilution.ItemsSource = liquidTypeList;

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

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

            #region 稀释方向
            ObservableCollection<DropdownName> dilutionDirectionList = DataModule.getInstance().GetDilutionDirectionList();
            cbDilutionDirection.ItemsSource = dilutionDirectionList;
            cbDilutionDirection.SelectedValue = EnumManagement.GetEnumValue(DilutionDirectionEnum.LeftToRight).ToString();
            #endregion

            #region 更换Tip
            ObservableCollection<DropdownName> changeTipList = DataModule.getInstance().GetChangeTipList();
            cbChangeTips.ItemsSource = cbChangeTipsDilution.ItemsSource = changeTipList;
            cbChangeTips.SelectedValue = cbChangeTipsDilution.SelectedValue = EnumManagement.GetEnumValue(ChangeTipEnum.NoChange).ToString();
            #endregion

            #region 吸头盒
            ObservableCollection<Labware> tipsList = DataRWDAL.LabwareDB.GetTipLabwareFromdb();
            cbTipsType.ItemsSource = tipsList;
            cbTipsType.SelectedIndex = 0;
            #endregion

            #region 混合：加液、取液位置类型
            ObservableCollection<DropdownName> mixPositionList = DataModule.getInstance().GetDispensePositionType();
            cbMixAspiratePosition.ItemsSource = mixPositionList;
            cbMixDispensePosition.ItemsSource = mixPositionList;
            #endregion

            // 命令标签
            tbxCommandLabel.Text = method.method_name;

            //mark = 0;
            methodDilution = new MethodDilution();
            methodDilution.name = method.method_name;
            methodDilution.label = method.method_name;
            methodDilution.status = (method.isEnabled == true ? "enable" : "disable");
            methodDilution.strIndex = method.strIndex;

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

            if (method.tag != null)
            {
                methodDilution = (MethodDilution)method.tag;
                channels = methodDilution.channels;
            }

            this.DataContext = methodDilution;
        }

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

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

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


            cbLiquidType.SelectedIndex = -1;
            cbLiquidType.SelectedValue = methodDilution.liquidTypeValueGradientDilution;
            cbLiquidTypeDilution.SelectedIndex= -1;
            cbLiquidTypeDilution.SelectedValue = methodDilution.liquidTypeValueAddDiluent;


            cbLiquidRange.SelectedIndex = -1;
            cbLiquidRange.SelectedValue = methodDilution.liquidRangeValueGradientDilution;
            cbLiquidRangeDilution.SelectedIndex = -1;
            cbLiquidRangeDilution.SelectedValue = methodDilution.liquidRangeValueAddDiluent;

            if (methodDilution.liquidValueGradientDilution == "")
            {
                cbLiquid.SelectedIndex = 0;
            }
            else
            {
                cbLiquid.SelectedValue = methodDilution.liquidValueGradientDilution;
            }

            if (methodDilution.liquidValueAddDiluent == "")
            {
                cbLiquidDilution.SelectedIndex = 0;
            }
            else
            {
                cbLiquidDilution.SelectedValue = methodDilution.liquidValueAddDiluent;
            }

        }

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

                }
            }
        }

        #region 初始化
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            mark += 1;
            try
            {
                if (mark > 1)
                {
                    return;
                }

                if (!string.IsNullOrEmpty(methodDilution.armValue))
                {
                    // 机械臂
                    cbArm.SelectedValue = methodDilution.armValue;
                    // 通道
                    tipsChannel.SelectedChannels = channels.ToList();
                    tipsChannel_SelectedChangedEvent(null, null);

                    // 吸头盒
                    cbTipsType.SelectedValue = methodDilution.labwaretipValue;

                    Labware labware = null;
                    #region 选择目标板 相关
                    // 板位名
                    tBlockTablePos.Text = methodDilution.positionTextGradientDilution;
                    // 选中的孔位
                    tbxWellPositionTips.Text = methodDilution.wellarrayGradientDilution;

                    // 孔位行列设置
                    labware = DataRWDAL.LabwareDB.GetLabware(methodDilution.labwareValueGradientDilution);
                    wellPlate.Rows = labware.number_row;
                    wellPlate.Columns = labware.number_column;

                    // 体积
                    tbxWellvolume.Text = methodDilution.volume.ToString();
                    // 液体类型
                    cbLiquidType.SelectedValue = methodDilution.liquidTypeValueGradientDilution;
                    // 液体范围
                    cbLiquidRange.SelectedValue = methodDilution.liquidRangeValueGradientDilution;
                    // 液体
                    cbLiquid.SelectedValue = methodDilution.liquidValueGradientDilution;

                    cbMixAspiratePosition.SelectedValue = methodDilution.mixAspiratePositionValue;
                    cbMixDispensePosition.SelectedValue = methodDilution.mixDispensePositionValue;

                    // 稀释方向
                    cbDilutionDirection.SelectedValue = EnumManagement.GetEnumValue(methodDilution.dilutionDirectionValue).ToString();
                    // 更换TipId
                    cbChangeTips.SelectedValue = methodDilution.changeTipsValueGradientDilution;
                    // 舍弃选中范围最后一行或最后一列多余的体积
                    cbDiscardLastVolume.IsChecked = methodDilution.isDiscardLastVolume;

                    #endregion

                    #region 梯度稀释设置 相关
                    // 板位名
                    tBlockTablePosDilution.Text = methodDilution.positionTextAddDiluent;
                    // 选中的孔位
                    tbxWellPositionTipsDilution.Text = methodDilution.wellarrayAddDiluent;

                    // 孔位行列设置
                    labware = DataRWDAL.LabwareDB.GetLabware(methodDilution.labwareValueAddDiluent);
                    wellPlateDilution.Rows = labware.number_row;
                    wellPlateDilution.Columns = labware.number_column;

                    // 稀释倍数
                    tbxDilutionFactor.Text = methodDilution.dilutionFactor.ToString();

                    // 液体类型
                    cbLiquidTypeDilution.SelectedValue = methodDilution.liquidTypeValueAddDiluent;
                    // 液体范围
                    cbLiquidRangeDilution.SelectedValue = methodDilution.liquidRangeValueAddDiluent;
                    // 液体
                    cbLiquidDilution.SelectedValue = methodDilution.liquidValueAddDiluent;
                    // 更换TipId
                    cbChangeTipsDilution.SelectedValue = methodDilution.changeTipsValueAddDiluent;
                    // 目标板选中范围的首行或首列加入稀释液
                    cbTargetSelectRangeFirstAddDiluent.IsChecked = methodDilution.isTargetSelectRangeFirstAddDiluent;
                    #endregion
                }

                if (cbArm.Items.Count > 1)
                {
                    cbArm.SelectedIndex = 1;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 命令名称
        /// <summary>
        /// 命令名称
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxCommandName_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.name = tbxCommandName.Text;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 选择目标板 相关

        #region 臂
        /// <summary>
        /// 臂
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbArm_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                tbxHeadType.Text = methodDilution.headType = string.Empty;
                // 臂未选择
                if (cbArm.SelectedIndex < 0 || cbArm.SelectedIndex == 0)
                {
                    tipsChannel.SetTotalChannelCount(0);
                    tipsChannel.SelectedChannels = new List<int>();
                    tipsChannel.SetSelectedChannels();
                    tipsChannel_SelectedChangedEvent(null, null);
                    return;
                }

                DeviceArm deviceArm = ((DeviceArm)cbArm.SelectedItem);

                // 移液枪
                if (deviceArm.arm_type == EnumManagement.GetEnumValue(ArmTypeEnum.Channel))
                {
                    // 初始通道信息
                    //methodDilution.channels = Shared.ChannelsId;
                    tipsChannel.SelectedChannels = Shared.ChannelsId.ToList();
                    tipsChannel.SetTotalChannelCount(Shared.ChannelCount);
                    tipsChannel.SetSelectedChannels();
                    tipsChannel_SelectedChangedEvent(null, null);
                }

                // 移液枪信息保存
                methodDilution.armText = deviceArm.device_arm_name;
                methodDilution.armValue = deviceArm.device_arm_id.ToString();
                tbxHeadType.Text = methodDilution.headType = deviceArm.head_type;
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 台面位置（梯度稀释用）     Del
        ///// <summary>
        ///// 梯度稀释范围 台面位置
        ///// </summary>
        ///// <param name="sender"></param>
        ///// <param name="e"></param>
        //private void comboboxTablePos_SelectionChanged(object sender, SelectionChangedEventArgs e)
        //{
        //    try
        //    {

        //    }
        //    catch (Exception ex)
        //    {
        //        LoggerHelper.ErrorLog("ERROR:", ex);
        //    }
        //}
        #endregion

        #region 孔位（梯度稀释用）
        /// <summary>
        /// 稀释范围 孔位
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxWellPositionTips_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.wellarrayGradientDilution = tbxWellPositionTips.Text;
                    //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;
            }
        }
        #endregion

        #region 体积
        /// <summary>
        /// 体积
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxWellvolume_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                try
                {
                    if (methodDilution != null)
                    {
                        methodDilution.volume = float.Parse(tbxWellvolume.Text);
                    }
                }
                catch (Exception ex)
                {
                    LoggerHelper.ErrorLog("ERROR:", ex);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 液体类型（梯度稀释用）
        /// <summary>
        /// 液体类型（梯度稀释用）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

        private void cbLiquidType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbLiquidType.SelectedIndex < 0)
                {
                    return;
                }

                if (cbLiquidType.SelectedIndex == 0)
                {
                    cbLiquidRange.SelectedIndex = 0;
                    cbLiquid.SelectedIndex = 0;
                }

                if (cbLiquidType.SelectedItem != null)
                {
                    LiquidType liquidType = (LiquidType)cbLiquidType.SelectedItem;

                    if (methodDilution != null)
                    {
                        methodDilution.liquidTypeTextGradientDilution = liquidType.liquid_type_name;
                        methodDilution.liquidTypeValueGradientDilution = liquidType.liquid_type_id;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 液体体积范围（梯度稀释用）
        /// <summary>
        /// 液体体积范围（梯度稀释用）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbLiquidRange_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                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 liquid = new Liquid();
                liquid.liquid_name = Properties.Resources.strPleaseSelect;
                liquidList.Insert(0, liquid);

                if (cbLiquidRange.SelectedIndex != 0)
                {
                    LiquidRange liquidRange = (LiquidRange)cbLiquidRange.SelectedItem;
                    if (methodDilution != null)
                    {
                        methodDilution.liquidRangeTextGradientDilution = liquidRange.liquid_range_name;
                        methodDilution.liquidRangeValueGradientDilution = liquidRange.liquid_range_id;
                    }
                }

                cbLiquid.ItemsSource = liquidList;
                cbLiquid.SelectedIndex = 0;
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 液体（梯度稀释用）
        /// <summary>
        /// 液体（梯度稀释用）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbLiquid_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbLiquid.SelectedIndex < 1)
                {
                    return;
                }

                if (cbLiquid.SelectedIndex != 0)
                {
                    Liquid liquid = cbLiquid.SelectedItem as Liquid;
                    if (methodDilution != null)
                    {
                        methodDilution.liquidTextGradientDilution = liquid.liquid_name;
                        methodDilution.liquidValueGradientDilution = liquid.liquid_id;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 稀释方向
        /// <summary>
        /// 稀释方向
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbDilutionDirection_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbDilutionDirection.SelectedIndex < 0)
                {
                    return;
                }

                DropdownName dilutionDirection = cbDilutionDirection.SelectedItem as DropdownName;
                if (methodDilution != null)
                {
                    methodDilution.dilutionDirectionText = dilutionDirection.dropdown_name;
                    methodDilution.dilutionDirectionValue = EnumManagement.GetField<DilutionDirectionEnum>(Convert.ToInt32(dilutionDirection.dropdown_id));
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 更换枪头
        /// <summary>
        /// 更换枪头
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbChangeTips_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbChangeTips.SelectedIndex < 0)
                {
                    return;
                }

                DropdownName changeTips = cbChangeTips.SelectedItem as DropdownName;
                if (methodDilution != null)
                {
                    methodDilution.changeTipsValueGradientDilution = changeTips.dropdown_id;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 舍弃选中范围最后一行或最后一列多余的体积
        /// <summary>
        /// 舍弃选中范围最后一行或最后一列多余的体积
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbDiscardLastVolume_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.isDiscardLastVolume = (bool)cbDiscardLastVolume.IsChecked;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 第一页
        /// <summary>
        /// 第一页
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnNext_Click(object sender, RoutedEventArgs e)
        {
            stepBar.Next();
            gridSelectTargetPlate.Visibility = Visibility.Collapsed;
            gridDilutionSetting.Visibility = Visibility.Visible;
            scrollViewer.ScrollToTop();
        }
        #endregion

        #endregion

        #region 梯度稀释设置 相关

        #region 稀释液 台面位置        Del
        ///// <summary>
        ///// 稀释液 台面位置
        ///// </summary>
        ///// <param name="sender"></param>
        ///// <param name="e"></param>
        //private void comboboxTablePosDilution_SelectionChanged(object sender, SelectionChangedEventArgs e)
        //{
        //    try
        //    {

        //    }
        //    catch (Exception ex)
        //    {
        //        LoggerHelper.ErrorLog("ERROR:", ex);
        //    }
        //}
        #endregion

        #region 稀释液 孔位
        /// <summary>
        /// 稀释液 孔位
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxWellPositionTipsDilution_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.wellarrayAddDiluent = tbxWellPositionTipsDilution.Text;
                    //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;
            }
        }
        #endregion

        #region 稀释倍数
        /// <summary>
        /// 稀释倍数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxDilutionFactor_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.dilutionFactor = Convert.ToInt32(tbxDilutionFactor.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 液体类型（稀释液）
        /// <summary>
        /// 液体类型（稀释液）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

        private void cbLiquidTypeDilution_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbLiquidTypeDilution.SelectedIndex < 0)
                {
                    return;
                }

                if (cbLiquidTypeDilution.SelectedIndex == 0)
                {
                    cbLiquidRangeDilution.SelectedIndex = 0;
                    cbLiquidDilution.SelectedIndex = 0;
                }

                if (cbLiquidTypeDilution.SelectedItem != null)
                {
                    LiquidType liquidType = (LiquidType)cbLiquidTypeDilution.SelectedItem;

                    if (methodDilution != null)
                    {
                        methodDilution.liquidTypeTextAddDiluent = liquidType.liquid_type_name;
                        methodDilution.liquidTypeValueAddDiluent = liquidType.liquid_type_id;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 液体体积范围（稀释液）
        /// <summary>
        /// 液体体积范围（稀释液）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbLiquidRangeDilution_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbLiquidRangeDilution.SelectedIndex < 0)
                {
                    return;
                }

                string typeID = cbLiquidTypeDilution.SelectedValue as string;
                string rangeID = cbLiquidRangeDilution.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 (cbLiquidRangeDilution.SelectedIndex != 0)
                {
                    LiquidRange liquidRange = (LiquidRange)cbLiquidRangeDilution.SelectedItem;
                    if (methodDilution != null)
                    {
                        methodDilution.liquidRangeTextAddDiluent = liquidRange.liquid_range_name;
                        methodDilution.liquidRangeValueAddDiluent = liquidRange.liquid_range_id;
                    }
                }

                cbLiquidDilution.ItemsSource = liquidList;
                cbLiquidDilution.SelectedIndex = 0;
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 液体（稀释液）
        /// <summary>
        /// 液体（稀释液）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbLiquidDilution_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbLiquidDilution.SelectedIndex < 1)
                {
                    return;
                }

                if (cbLiquidDilution.SelectedIndex != 0)
                {
                    Liquid liquid = cbLiquidDilution.SelectedItem as Liquid;
                    if (methodDilution != null)
                    {
                        methodDilution.liquidTextAddDiluent = liquid.liquid_name;
                        methodDilution.liquidValueAddDiluent = liquid.liquid_id;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 更换枪头（稀释液）
        /// <summary>
        /// 更换枪头（稀释液）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbChangeTipsDilution_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbChangeTipsDilution.SelectedIndex < 0)
                {
                    return;
                }

                DropdownName changeTips = cbChangeTipsDilution.SelectedItem as DropdownName;
                if (methodDilution != null)
                {
                    methodDilution.changeTipsValueAddDiluent = changeTips.dropdown_id;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        #endregion

        #region 上一页
        /// <summary>
        /// 上一页
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnPrev_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                stepBar.Prev();
                gridSelectTargetPlate.Visibility = Visibility.Visible;
                gridDilutionSetting.Visibility = Visibility.Collapsed;
                scrollViewer.ScrollToTop();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 目标板选中范围的首行或首列加入稀释液
        /// <summary>
        /// 目标板选中范围的首行或首列加入稀释液
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbTargetSelectRangeFirstAddDiluent_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.isTargetSelectRangeFirstAddDiluent = (bool)cbTargetSelectRangeFirstAddDiluent.IsChecked;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        #endregion

        #endregion

        #region 命令标签
        /// <summary>
        /// 命令标签
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxCommandLabel_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.label = tbxCommandLabel.Text;
                    methodDilution.name = tbxCommandName.Text.ToString();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        #endregion

        #region 点击布局板位回调事件
        /// <summary>
        /// 点击布局板位回调事件
        /// </summary>
        /// <param name="tableName"></param>
        /// <param name="lb"></param>
        public void SetTableName(string tableName, Labware lb)
        {
            try
            {
                if (lb == null || string.IsNullOrEmpty(lb.labware_id))
                {
                    return;
                }

                if (string.IsNullOrEmpty(methodDilution.armValue))
                {
                    new MessageDialog(Properties.Resources.msgPlsSelectArm).ShowDialog();
                    return;
                }

                List<Lattice> latticeList = DataRWDAL.LatticeDB.GetLatticeDataFromdb(Shared.SoftwareInformation.software_device_number,
                    Convert.ToInt32(methodDilution.armValue));

                // [选择目标板]表示时
                if (gridSelectTargetPlate.Visibility == Visibility.Visible)
                {
                    wellPlate.Rows = lb.number_row;
                    wellPlate.Columns = lb.number_column;
                    tbxWellPositionTips.Text = string.Empty;

                    Lattice lattice = latticeList.Find(s => s.lattice_num == tableName);
                    if (lattice == null)
                    {
                        LoggerHelper.InfoLog("Error: Can't find lattice with lattice_num=" + tableName);
                        return;
                    }
                    tBlockTablePos.Text = tableName;

                    if (methodDilution != null)
                    {
                        methodDilution.positionTextGradientDilution = tableName;
                        methodDilution.positionValueGradientDilution = lattice.lattice_id;
                        methodDilution.labwareTextGradientDilution = lb.labware_name;
                        methodDilution.labwareValueGradientDilution = lb.labware_id;
                    }
                }
                // [梯度稀释设置]表示时
                else if (gridDilutionSetting.Visibility == Visibility.Visible)
                {
                    wellPlateDilution.Rows = lb.number_row;
                    wellPlateDilution.Columns = lb.number_column;
                    tbxWellPositionTipsDilution.Text = string.Empty;

                    Lattice lattice = latticeList.Find(s => s.lattice_num == tableName);
                    if (lattice == null)
                    {
                        LoggerHelper.InfoLog("Error: Can't find lattice with lattice_num=" + tableName);
                        return;
                    }
                    tBlockTablePosDilution.Text = tableName;
                    if (methodDilution != null)
                    {
                        methodDilution.positionTextAddDiluent = tableName;
                        methodDilution.positionValueAddDiluent = lattice.lattice_id;
                        methodDilution.labwareTextAddDiluent = lb.labware_name;
                        methodDilution.labwareValueAddDiluent = lb.labware_id;
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

        }
        #endregion

        #region 吸头盒
        /// <summary>
        /// 吸头盒
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbTipsType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (cbTipsType.SelectedIndex < 0)
                {
                    return;
                }

                Labware labware = cbTipsType.SelectedItem as Labware;
                if (methodDilution != null)
                {
                    methodDilution.labwaretipText = labware.labware_name;
                    methodDilution.labwaretipValue = labware.labware_id.ToString();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

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

        #region 混合
        /// <summary>
        /// 混合
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void checkboxMix_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (methodDilution == null)
                {
                    return;
                }

                methodDilution.bMix = (bool)checkboxMix.IsChecked;

                methodDilution.mixcount = Convert.ToInt32(tbxMixCount.Text);
                methodDilution.mixvolume = Convert.ToDouble(tbxMixVolume.Text);
                methodDilution.mixAspiratePositionText = cbMixAspiratePosition.Text;
                methodDilution.mixAspiratePositionValue = Convert.ToInt32(cbMixAspiratePosition.SelectedValue);
                methodDilution.mixAspirateDistance = Convert.ToDouble(tbxMixAspirateDistance.Text);
                methodDilution.mixAspirateSpeed = Convert.ToDouble(tbxMixAspirateSpeed.Text);

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

        /// <summary>
        /// 混合体积
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxMixVolume_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.mixvolume = Convert.ToDouble(tbxMixVolume.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 混合次数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxMixCount_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.mixcount = Convert.ToInt32(tbxMixCount.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 吸液时距离方式
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cbMixAspiratePosition_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.mixAspiratePositionValue = Convert.ToInt32(cbMixAspiratePosition.SelectedValue);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 吸液距离值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxMixAspirateDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.mixAspirateDistance = Convert.ToDouble(tbxMixAspirateDistance.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 吸液速度
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxMixAspirateSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.mixAspirateSpeed = Convert.ToDouble(tbxMixAspirateSpeed.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        private void cbMixDispensePosition_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.mixDispensePositionValue = Convert.ToInt32(cbMixDispensePosition.SelectedValue);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 放液距离值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxMixDispenseDistance_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.mixDispenseDistance = Convert.ToDouble(tbxMixDispenseDistance.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 放液速度
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbxMixDispenseSpeed_TextChanged(object sender, TextChangedEventArgs e)
        {
            try
            {
                if (methodDilution != null)
                {
                    methodDilution.mixDispenseSpeed = Convert.ToDouble(tbxMixDispenseSpeed.Text);
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        #endregion
    }
}