using DataEntity.Rack;
using DataEntity.Share;
using DataRWDAL.Rack;
using DriverLib.Engine;
using HandyControl.Data;
using HxEnum;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Threading;
using System.Xml;
using XCommon.Log;
using XCommon.Tip;
using XHandler.View.MethodProperty;
using XImagingXhandler.XDAL;
using ResultType = DriverLib.Engine.ResultType;
using DataRWDAL;
using XHandler.View.Liquids;
using XHandler.Class;
using XCoreBLL;
using XImaging.Automation.Service.Interface;
using MySqlX.XDevAPI.Common;
using System.Reflection;
using System.Threading.Tasks;
using System.Configuration;
using DataEntity;
using System.Windows.Controls;
using XCommon;
using XHandler.Class.DataEx;
using XHandler.Controls.Run.Com;
using XHandler.Controls;

namespace XHandler.View
{
    /// <summary>
    /// 设置页面
    /// </summary>
    public partial class SystemSettings : Window
    {
        private System.Threading.Timer heartConnectTimer = null;
        private List<SoftwareInformationDevice> softwareInformationDevices = new List<SoftwareInformationDevice>();
        private DispatcherTimer checkAndSetTimer;//用于检查更新已使用时长

        #region 选项卡选中Flg
        private bool currentChannelIsChecked = false;
        private bool currentLedIsChecked = false;
        private bool currentLatticeIsChecked = false;
        private bool currentRackIsChecked = false;
        private bool currentOtherIsChecked = false;
        #endregion

        private bool isInit = false;
        public MainWindow mainWindow = null;

        #region 构造函数
        public SystemSettings()
        {
            InitializeComponent();
            btnSetLed_Click(null, null);

            this.Owner = (Window)Shared.Main;
        }
        #endregion

        #region 初期表示
        private void SytemSettings_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                isInit = true;
                // 获取软件信息
                softwareInformationDevices = SoftwareInnerDeviceDB.GetSoftDeviceData(Shared.SoftwareInformation.software_information_id);

                #region 状态同步
                if (MethodAction.Instance == null)
                {
                    return;
                }
                LoggerHelper.DebugLog($"[SytemSettings_Loaded]: FloodlightStatus(LED) = {MethodAction.Instance.FloodlightStatus}," +
                    $" SterilizingLampStatus(UV) = {MethodAction.Instance.SterilizingLampStatus}, FFUStatus(FFU) = {MethodAction.Instance.FFUStatus},");

                #region LED
                if (MethodAction.Instance.FloodlightStatus)
                {
                    radioBtnLedStart.IsChecked = true;
                }
                else
                {
                    radioBtnLedEnd.IsChecked = true;
                }
                #endregion

                #region UV
                if (MethodAction.Instance.SterilizingLampStatus)
                {
                    radioBtnUVStart.IsChecked = true;
                }
                else
                {
                    radioBtnUVEnd.IsChecked = true;
                }
                #endregion

                #region FFU
                if (MethodAction.Instance.FFUStatus)
                {
                    radioBtnHEPAStart.IsChecked = true;
                }
                else
                {
                    radioBtnHEPAEnd.IsChecked = true;
                }
                #endregion

                #region 暂存架
                bool isEnableRack = Shared.SoftwareInformation.is_enable_rack == EnumManagement.GetEnumValue(isEnableRackEnum.Yes) ? true : false;
                cBoxEnableRack.IsChecked = isEnableRack;

                var rackConfigModel = RackConfigDB.GetInfo(Shared.SoftwareInformation.software_information_id);
                if (rackConfigModel != null)
                {
                    numRackNum.Value = rackConfigModel.rack_num;
                    numLayerNum.Value = rackConfigModel.rack_layer;
                }

                cBoxEnableRack_Click(null, null);

                // 加载暂存架
                LoadStack();
                #endregion

                #region 全局速度
                sldSystemTuneVal.Value = Shared.SoftwareInformation.global_speed;
                #endregion

                #region 通道
                var queryResult = Shared.DeviceArmList.Where(x => x.software_information_id.Equals(Shared.SoftwareInformation.software_information_id) && x.arm_type.Equals(1));
                List<DeviceArm> deviceArmList = queryResult.ToList();//(List<DeviceArm>)Shared.DeviceArmList.SelectMany(x => x.software_information_id.Equals(Shared.SoftwareInformation.software_information_id) && x.arm_type.Equals(1));
                int countOfArm = 0;//arm计数
                foreach (DeviceArm deviceArm in deviceArmList)
                {
                    if (countOfArm == 0)
                    {
                        tbkChannelOne.Text = deviceArm.device_arm_name + "通道设置";
                        spChannelOne.Visibility = Visibility.Visible;
                        tipsChannelDisOne.TotalChannels = deviceArm.channels;
                        tipsChannelDisOne.SetTotalChannelCount(deviceArm.channels);
                        tipsChannelDisOne.Tag = deviceArm;
                        if (deviceArm.device_arm_property == "")
                        {
                            tipsChannelDisOne.SelectedChannels = new List<int> { };
                            tipsChannelDisOne.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++)
                        {
                            if (strChannels[j].Contains("泵"))
                            {
                                iChannels[j] = Convert.ToInt32(strChannels[j].Substring(1));
                            }
                            else
                            {
                                iChannels[j] = Convert.ToInt32(strChannels[j]);
                            }
                        }

                        if (iChannels.Length > 0)
                        {
                            tipsChannelDisOne.SelectedChannels = iChannels.ToList();
                            tipsChannelDisOne.SetSelectedChannels();
                        }
                    }
                    else if (countOfArm == 1)
                    {
                        tbkChannelTwo.Text = deviceArm.device_arm_name + "通道设置";
                        spChannelTwo.Visibility = Visibility.Visible;
                        tipsChannelDisTwo.TotalChannels = deviceArm.channels;
                        tipsChannelDisTwo.SetTotalChannelCount(deviceArm.channels);
                        tipsChannelDisTwo.Tag = deviceArm;
                        if (deviceArm.device_arm_property == "")
                        {
                            tipsChannelDisTwo.SelectedChannels = new List<int> { };
                            tipsChannelDisTwo.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++)
                        {
                            if (strChannels[j].Contains("泵"))
                            {
                                iChannels[j] = Convert.ToInt32(strChannels[j].Substring(1));
                            }
                            else
                            {
                                iChannels[j] = Convert.ToInt32(strChannels[j]);
                            }
                        }

                        if (iChannels.Length > 0)
                        {
                            tipsChannelDisTwo.SelectedChannels = iChannels.ToList();
                            tipsChannelDisTwo.SetSelectedChannels();
                        }
                    }
                    else if (countOfArm == 2)
                    {
                        tbkChannelThree.Text = deviceArm.device_arm_name + "通道设置";
                        spChannelThree.Visibility = Visibility.Visible;
                        tipsChannelDisThree.TotalChannels = deviceArm.channels;
                        tipsChannelDisThree.SetTotalChannelCount(deviceArm.channels);
                        tipsChannelDisThree.Tag = deviceArm;
                        if (deviceArm.device_arm_property == "")
                        {
                            tipsChannelDisThree.SelectedChannels = new List<int> { };
                            tipsChannelDisThree.SetSelectedChannels();
                            return;
                        }
                        string[] strChannels = deviceArm.device_arm_property.Trim().Split(',');
                        int[] iChannels = new int[strChannels.Length];
                        for (int j = 0; j < strChannels.Length; j++)
                        {
                            if (strChannels[j].Contains("泵"))
                            {
                                iChannels[j] = Convert.ToInt32(strChannels[j].Substring(1));
                            }
                            else
                            {
                                iChannels[j] = Convert.ToInt32(strChannels[j]);
                            }
                        }

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


                    countOfArm++;
                }
                #endregion
                #endregion

                #region 权限控制
                string userid = UserDB.GetUserInfByUserName(Shared.User.username).id;
                //所有菜单
                List<RoleMenu> roleMenuAllList = UserDB.GetWholeRoleMenuByUserId(userid);
                //权限控制
                var MenuSystemSetting = roleMenuAllList.FirstOrDefault(x => x.rolemenuname.Equals(MenuName.MenuSystemSetting));
                if (MenuSystemSetting != null)
                {
                    var SubMenuLightSetting = MenuSystemSetting.rolemenuchildren.FirstOrDefault(x => x.rolemenuname.Equals(MenuName.SubMenuLightSetting));
                    if (SubMenuLightSetting != null)
                    {
                        btnSetLed.Visibility = Visibility.Visible;
                        ClearIsCheckeFlg();
                        currentLedIsChecked = true;
                        // 切换选项卡
                        SwitchTab();
                        gdSetLedContent.Visibility = System.Windows.Visibility.Visible;
                        gdTabButtons.ColumnDefinitions[0].Width = new GridLength(137.5);
                    }
                    else
                    {
                        btnSetLed.Visibility = Visibility.Collapsed;
                        gdSetLedContent.Visibility = System.Windows.Visibility.Collapsed;
                        gdTabButtons.ColumnDefinitions[0].Width = new GridLength(0);
                    }

                    var SubMenuSetRack = MenuSystemSetting.rolemenuchildren.FirstOrDefault(x => x.rolemenuname.Equals(MenuName.SubMenuSetRack));
                    if (SubMenuSetRack != null)
                    {
                        btnSetRack.Visibility = Visibility.Visible;
                        ClearIsCheckeFlg();
                        currentRackIsChecked = true;
                        // 切换选项卡
                        SwitchTab();
                        gdSetRackContent.Visibility = System.Windows.Visibility.Visible;
                        gdTabButtons.ColumnDefinitions[1].Width = new GridLength(137.5);
                    }
                    else
                    {
                        btnSetRack.Visibility = Visibility.Collapsed;
                        gdSetRackContent.Visibility = System.Windows.Visibility.Collapsed;
                        gdTabButtons.ColumnDefinitions[1].Width = new GridLength(0);
                    }

                    var MenuChannelSetting = MenuSystemSetting.rolemenuchildren.FirstOrDefault(x => x.rolemenuname.Equals(MenuName.MenuChannelSetting));
                    if (MenuChannelSetting != null)
                    {
                        btnSetChannel.Visibility = Visibility.Visible;
                        ClearIsCheckeFlg();
                        currentChannelIsChecked = true;
                        // 切换选项卡
                        SwitchTab();
                        gdSetChannelContent.Visibility = System.Windows.Visibility.Visible;
                        gdTabButtons.ColumnDefinitions[2].Width = new GridLength(137.5);
                        if (Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceHXFX)
                        {
                            spChannelPump.Visibility = Visibility.Visible;
                            spChannelPumpDispens.Visibility = Visibility.Visible;
                            btnDispense.Visibility = Visibility.Visible;
                        }
                    }
                    else
                    {
                        btnSetChannel.Visibility = Visibility.Collapsed;
                        gdSetChannelContent.Visibility = System.Windows.Visibility.Collapsed;
                        gdTabButtons.ColumnDefinitions[2].Width = new GridLength(0);
                        if (Shared.SoftwareInformation.software_device_number == DeviceCategory.DeviceHXFX)
                        {
                            spChannelPump.Visibility = Visibility.Collapsed;
                            spChannelPumpDispens.Visibility = Visibility.Collapsed;
                            btnDispense.Visibility = Visibility.Collapsed;
                        }
                    }

                    var SubMenuSetOthers = MenuSystemSetting.rolemenuchildren.FirstOrDefault(x => x.rolemenuname.Equals(MenuName.SubMenuSetOthers));
                    if (SubMenuSetOthers != null)
                    {
                        btnSetOther.Visibility = Visibility.Visible;
                        ClearIsCheckeFlg();
                        currentOtherIsChecked = true;
                        // 切换选项卡
                        SwitchTab();
                        gdSetOtherContent.Visibility = System.Windows.Visibility.Visible;
                        gdTabButtons.ColumnDefinitions[3].Width = new GridLength(137.5);
                    }
                    else
                    {
                        btnSetOther.Visibility = Visibility.Collapsed;
                        gdSetOtherContent.Visibility = System.Windows.Visibility.Collapsed;
                        gdTabButtons.ColumnDefinitions[3].Width = new GridLength(0);
                    }
                }
                #endregion

                VolumeVal volumeVal = new VolumeVal();
                volumeVal.Volume1 = 0;
                volumeVal.Volume2 = 0;
                volumeVal.Volume3 = 0;
                volumeVal.Volume4 = 0;
                this.DataContext = volumeVal;
            }
            catch(Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR SytemSettings_Loaded:", ex);
            }
        }
        #endregion

        #region 设置通道
        private void btnSetChannel_Click(object sender, RoutedEventArgs e)
        {
            if (!currentChannelIsChecked)
            {
                // 清除选项卡选中状态
                ClearIsCheckeFlg();
                currentChannelIsChecked = true;

                // 切换选项卡
                SwitchTab();
            }
        }
        #endregion

        #region 台面示教
        private void btnSetLattice_Click(object sender, RoutedEventArgs e)
        {
            if (!currentLatticeIsChecked)
            {
                // 清除选项卡选中状态
                ClearIsCheckeFlg();
                currentLatticeIsChecked = true;

                // 切换选项卡
                SwitchTab();
            }
        }
        #endregion

        #region 灯光设置
        private void btnSetLed_Click(object sender, RoutedEventArgs e)
        {
            if (!currentLedIsChecked)
            {
                // 清除选项卡选中状态
                ClearIsCheckeFlg();
                currentLedIsChecked = true;

                // 切换选项卡
                SwitchTab();
            }
        }

        #region UV
        /// <summary>
        /// 开启UV
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void radioBtnUVStart_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                // 开启UV
                DoUV();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 关闭UV
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void radioBtnUVEnd_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                // 关闭UV
                DoUV();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 开启、关闭UV
        /// </summary>
        private void DoUV()
        {
            if (!isInit)
            {
                return;
            }

            int onOffStatus = radioBtnUVStart.IsChecked == true ? EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOn) : EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOff);

            HxResult ret = MethodAction.Instance.SterilizingLamp(onOffStatus);
            if (ret.Result == ResultType.Success)
            {
                LoggerHelper.InfoLog("[DoUV]:操作UV成功");

                // 紫外灯与LED灯互斥
                if (onOffStatus == EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOn))
                {
                    ret = MethodAction.Instance.Floodlight(EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOff));
                    LoggerHelper.InfoLog(string.Format("[DoUV]:UV打开，LED关闭 status = {0}", ret.Result.ToString()));

                    // LED
                    if (ret.Result == ResultType.Success)
                    {
                        radioBtnLedEnd.IsChecked = true;
                    }
                }
            }
            else
            {
                LoggerHelper.ErrorLog("[DoUV]:操作UV失败，信息：" + ret.AlarmInfo.ToString());
            }
        }
        #endregion

        #region HEPA
        /// <summary>
        /// 开启HEPA
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void radioBtnHEPAStart_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                // 开启HEPA
                DoHEPA();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 关闭HEPA
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void radioBtnHEPAEnd_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                // 关闭HEPA
                DoHEPA();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 开启、关闭HEPA
        /// </summary>
        private void DoHEPA()
        {
            if (!isInit)
            {
                return;
            }

            int onOffStatus = radioBtnHEPAStart.IsChecked == true ? EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOn) : EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOff);
            HxResult ret = MethodAction.Instance.FFU(onOffStatus);
            if (ret.Result == ResultType.Success)
            {
                LoggerHelper.InfoLog("[DoHEPA]:操作HEPA成功");
            }
            else
            {
                LoggerHelper.ErrorLog("[DoHEPA]:操作HEPA失败，信息：" + ret.AlarmInfo.ToString());
            }
        }
        #endregion

        #region LED
        /// <summary>
        /// 开启LED
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void radioBtnLedStart_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                // 开启LED
                DoLed();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 关闭LED
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void radioBtnLedEnd_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                // 关闭LED
                DoLed();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 开启、关闭LED
        /// </summary>
        private void DoLed()
        {
            if (!isInit)
            {
                return;
            }

            int onOffStatus = radioBtnLedStart.IsChecked == true ? EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOn) : EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOff);
            HxResult ret = MethodAction.Instance.Floodlight(onOffStatus);
            if (ret.Result == ResultType.Success)
            {
                LoggerHelper.InfoLog("[DoLed]:操作LED成功");

                // 紫外灯与LED灯互斥
                if (onOffStatus == EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOn))
                {
                    ret = MethodAction.Instance.SterilizingLamp(EnumManagement.GetEnumValue(DeviceStateModeEnum.TurnOff));
                    LoggerHelper.InfoLog(string.Format("[DoLed]:LED打开，UV关闭 status = {0}", ret.Result.ToString()));

                    // UV
                    if (ret.Result == ResultType.Success)
                    {
                        radioBtnUVEnd.IsChecked = true;
                    }
                }
            }
            else
            {
                LoggerHelper.ErrorLog("[DoLed]:操作LED失败，信息：" + ret.AlarmInfo.ToString());
            }
        }
        #endregion
        #endregion

        #region 板架设置
        #region 板架选项卡点击事件
        /// <summary>
        /// 板架选项卡点击事件
        /// </summary>
        private void btnSetRack_Click(object sender, RoutedEventArgs e)
        {
            if (!currentRackIsChecked)
            {
                // 清除选项卡选中状态
                ClearIsCheckeFlg();
                currentRackIsChecked = true;

                // 切换选项卡
                SwitchTab();
            }
        }
        #endregion

        #region 加载暂存架
        /// <summary>
        /// 加载暂存架
        /// </summary>
        private void LoadStack()
        {
            // 根据项目ID，获取暂存架详细List
            var racksetLayerList = RacksetLayerDB.GetList(Shared.SoftwareInformation.software_information_id);
            var rackConfigModel = RackConfigDB.GetInfo(Shared.SoftwareInformation.software_information_id);

            stackStackPanel.Children.Clear();

            if (rackConfigModel != null)
            {
                for (int rackNumIndex = 1; rackNumIndex <= rackConfigModel.rack_num; rackNumIndex++)
                {
                    var sel = racksetLayerList.Where(it => it.rack_num == rackNumIndex);
                    if (sel.Any())
                    {
                        List<RacksetLayerModel> racksetLayerListByRackNum = sel.Reverse().ToList();
                        RackColumnItem stackColumnItem = new RackColumnItem(racksetLayerListByRackNum);
                        stackColumnItem.RackNum = rackNumIndex;
                        stackColumnItem.Margin = new Thickness(0, 10, 10, 0);
                        stackColumnItem.ReLoadRackEventForColumnItem -= ReLoadRackInfoEvent;
                        stackColumnItem.ReLoadRackEventForColumnItem += ReLoadRackInfoEvent;
                        stackStackPanel.Children.Add(stackColumnItem);
                    }
                }
            }
        }
        #endregion

        #region 启用暂存架
        /// <summary>
        /// 启用暂存架
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cBoxEnableRack_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                bool isEnable = (bool)cBoxEnableRack.IsChecked;

                numRackNum.IsEnabled = isEnable;
                numLayerNum.IsEnabled = isEnable;

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

        #region 确定
        /// <summary>
        /// 确定
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSetRackOk_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                PlsToolTipWin plsToolTipWin = new PlsToolTipWin("继续操作会清除暂存架的相关信息，确定要更新吗？");
                plsToolTipWin.ShowDialog();
                if (plsToolTipWin.DialogResult != true)
                {
                    return;
                }

                bool isChecked = (bool)cBoxEnableRack.IsChecked;

                // 更新系统配置表
                Shared.SoftwareInformation.is_enable_rack = isChecked ? EnumManagement.GetEnumValue(isEnableRackEnum.Yes) : EnumManagement.GetEnumValue(isEnableRackEnum.No);
                SoftwareInformationDB.Update(Shared.SoftwareInformation);

                // 删除本项目的所有暂存架信息
                RacksetLayerDB.DelBySoftwareInformationId(Shared.SoftwareInformation.software_information_id);
                PositionDB.DelBySoftwareInformationId(Shared.SoftwareInformation.software_information_id, EnumManagement.GetEnumValue(PositonTypeEnum.Rack));

                #region 更新暂存架配置信息
                int rackNum = int.Parse(numRackNum.Value.ToString());
                int layerNum = int.Parse(numLayerNum.Value.ToString());

                var rackConfigModel = RackConfigDB.GetInfo(Shared.SoftwareInformation.software_information_id);
                if (rackConfigModel != null)
                {
                    rackConfigModel.rack_num = rackNum;
                    rackConfigModel.rack_layer = layerNum;
                    rackConfigModel.modify_name = Shared.User.username;
                    rackConfigModel.modify_time = DateTime.Now;
                    RackConfigDB.Update(rackConfigModel);
                }
                else
                {
                    rackConfigModel = new RackConfigModel();
                    rackConfigModel.id = Guid.NewGuid().ToString();
                    rackConfigModel.rack_num = rackNum;
                    rackConfigModel.rack_layer = layerNum;
                    rackConfigModel.software_information_id = Shared.SoftwareInformation.software_information_id;
                    rackConfigModel.creat_name = Shared.User.username;
                    rackConfigModel.create_time = DateTime.Now;
                    RackConfigDB.Add(rackConfigModel);
                }
                #endregion

                #region 生成暂存架详细
                List<RacksetLayerModel> lstRacksetLayer = new List<RacksetLayerModel>();
                List<PositionModel> lstPosition = new List<PositionModel>();

                for (int rackNumIndex = 1; rackNumIndex <= rackNum; rackNumIndex++)
                {
                    for (int layerNumIndex = 1; layerNumIndex <= layerNum; layerNumIndex++)
                    {
                        RacksetLayerModel racksetLayer = new RacksetLayerModel();
                        racksetLayer.id = Guid.NewGuid().ToString();
                        racksetLayer.labware_id = string.Empty;
                        racksetLayer.is_has_labware = EnumManagement.GetEnumValue(IsHasLabwareEnum.No);
                        racksetLayer.rack_name = racksetLayer.point_name = string.Format("R{0}-{1}", rackNumIndex, layerNumIndex);
                        racksetLayer.rack_num = rackNumIndex;
                        racksetLayer.rack_layer = layerNumIndex;
                        racksetLayer.creat_name = Shared.User.username;
                        racksetLayer.create_time = DateTime.Now;
                        racksetLayer.software_information_id = Shared.SoftwareInformation.software_information_id;
                        lstRacksetLayer.Add(racksetLayer);

                        #region 点位
                        {
                            PositionModel positionModel = new PositionModel();
                            positionModel.id = Guid.NewGuid().ToString();
                            positionModel.type = EnumManagement.GetEnumValue(PositonTypeEnum.Rack);
                            positionModel.name = racksetLayer.point_name;
                            positionModel.relation_Id = racksetLayer.id;
                            positionModel.software_information_id = Shared.SoftwareInformation.software_information_id;
                            positionModel.creat_name = Shared.User.username;
                            positionModel.create_time = DateTime.Now;
                            lstPosition.Add(positionModel);
                        }
                        #endregion
                    }
                }

                RacksetLayerDB.AddList(lstRacksetLayer);
                PositionDB.AddList(lstPosition);
                #endregion

                // 加载暂存架
                LoadStack();

                ShowTip.ShowNotice("保存成功", InfoType.Success);
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region 重新加载暂存架板位信息事件
        /// <summary>
        /// 重新加载暂存架板位信息事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ReLoadRackInfoEvent(object sender, EventArgs e)
        {
            try
            {
                // 加载暂存架
                LoadStack();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion
        #endregion

        #region 其他设置
        /// <summary>
        /// 其他设置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSetOther_Click(object sender, RoutedEventArgs e)
        {
            if (!currentOtherIsChecked)
            {
                // 清除选项卡选中状态
                ClearIsCheckeFlg();
                currentOtherIsChecked = true;

                // 切换选项卡
                SwitchTab();
            }
        }

        /// <summary>
        /// 速度滑块滑动事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void sldSystemTuneVal_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            try
            {
                if (txtSystemSpeedVal != null)
                {
                    txtSystemSpeedVal.Text = sldSystemTuneVal.Value.ToString();
                    if (MethodAction.Instance != null)
                    {
                        Shared.SoftwareInformation.global_speed = MethodAction.Instance.GlobalSpeed = (float)Convert.ToDouble(txtSystemSpeedVal.Text);
                        SoftwareInformationDB.UpdateSpeed(Shared.SoftwareInformation);
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }

        /// <summary>
        /// 速度滑块MouseUp事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void sldSystemTuneVal_MouseUp(object sender, MouseButtonEventArgs e)
        {
            if (txtSystemSpeedVal != null)
            {
                //txtSystemSpeedVal.Text = sldSystemTuneVal.Value.ToString();
                if (MethodAction.Instance != null)
                {
                    MethodAction.Instance.GlobalSpeed = (float)Convert.ToDouble(txtSystemSpeedVal.Text);
                }
            }
        }
        #endregion

        #region 关闭窗口
        private void btnClose_Click(object sender, RoutedEventArgs e)
        {
            if (heartConnectTimer != null)
            {
                heartConnectTimer.Dispose();
            }
            this.Close();
        }
        #endregion

        #region 操作选项卡
        /// <summary>
        /// 清除选项卡选中状态
        /// </summary>
        private void ClearIsCheckeFlg()
        {
            currentChannelIsChecked = false;
            currentLedIsChecked = false;
            currentLatticeIsChecked = false;
            currentRackIsChecked = false;
            currentOtherIsChecked = false;
        }

        /// <summary>
        /// 切换选项卡
        /// </summary>
        private void SwitchTab()
        {
            SolidColorBrush activeBrush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 74, 186, 249));
            SolidColorBrush noActiveBrush = Brushes.Black;

            gdSetChannelContent.Visibility = System.Windows.Visibility.Hidden;
            gdSetLatticeContent.Visibility = System.Windows.Visibility.Hidden;
            gdSetLedContent.Visibility = System.Windows.Visibility.Hidden;
            gdSetRackContent.Visibility = System.Windows.Visibility.Hidden;
            gdSetOtherContent.Visibility = System.Windows.Visibility.Hidden;

            btnSetLed.Foreground = noActiveBrush;
            btnSetLed.BorderThickness = new Thickness(0, 0, 0, 0);
            btnSetRack.Foreground = noActiveBrush;
            btnSetRack.BorderThickness = new Thickness(0, 0, 0, 0);
            btnSetChannel.Foreground = noActiveBrush;
            btnSetChannel.BorderThickness = new Thickness(0, 0, 0, 0);
            btnSetOther.Foreground = noActiveBrush;
            btnSetOther.BorderThickness = new Thickness(0, 0, 0, 0);

            if (currentLedIsChecked)
            {
                btnSetLed.Foreground = (Brush)activeBrush;
                btnSetLed.BorderThickness = new Thickness(0, 0, 0, 3);
                gdSetLedContent.Visibility = Visibility.Visible;
            }
            else if (currentRackIsChecked)
            {
                btnSetRack.Foreground = (Brush)activeBrush;
                btnSetRack.BorderThickness = new Thickness(0, 0, 0, 3);
                gdSetRackContent.Visibility = Visibility.Visible;
            }
            else if(currentChannelIsChecked)
            {
                btnSetChannel.Foreground = (Brush)activeBrush;
                btnSetChannel.BorderThickness = new Thickness(0, 0, 0, 3);
                gdSetChannelContent.Visibility = Visibility.Visible;
            }
            else if (currentOtherIsChecked)
            {
                btnSetOther.Foreground = (Brush)activeBrush;
                btnSetOther.BorderThickness = new Thickness(0, 0, 0, 3);
                gdSetOtherContent.Visibility = Visibility.Visible;
            }
        }
        #endregion

        #region 拖动窗体
        /// <summary>
        /// 拖动窗体
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Grid_MouseDown(object sender, MouseButtonEventArgs e)
        {
            try
            {
                if (e.ChangedButton == MouseButton.Left)
                {
                    this.DragMove();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        #region ESC关闭画面
        /// <summary>
        /// ESC关闭画面
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Window_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            try
            {
                if (e.Key == Key.Escape)
                {
                    this.Close();
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
        }
        #endregion

        private void btnLoadImage_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                RunWnd.currentIsUsedWellLattice.Clear();
                string directoryBase = System.AppDomain.CurrentDomain.BaseDirectory;
                string xmlFilePath = directoryBase + "Config\\" + "CurrentUsedTips.xml";
                if (File.Exists(xmlFilePath))
                {
                    File.Delete(xmlFilePath);
                }

                //循环所有现有方法下的Tip头，然后回复原状
                string shortDir = "method";
                
                string fullName = ConfigurationManager.AppSettings["MethodFileBasePath"].ToString();//AppDomain.CurrentDomain.BaseDirectory + shortDir;
                if (Directory.Exists(fullName))
                {
                    string[] fileNameList = Directory.GetFiles(fullName);

                    foreach (string fileName in fileNameList)
                    {
                        string suffix = fileName.Substring(fileName.LastIndexOf('.') + 1, (fileName.Length - fileName.LastIndexOf('.') - 1));
                        if (suffix == "xmed")
                        {
                            XmlDocument xmldoc = new XmlDocument();
                            xmldoc.Load(fileName);

                            //XmlNodeList xnlist = xmldoc.SelectNodes("root/env/platform");

                            //if (xnlist != null)
                            //{
                            //    foreach (XmlNode xn in xnlist)
                            //    {
                            //        var n = xn.SelectSingleNode("labware_id").InnerText;
                            //        //查询出是Tip头类型，则重置

                            //        Labware labware = LabwareDB.GetLabware(n);
                            //        if (labware.labware_type_id == "6")
                            //        {
                            //            xn.SelectSingleNode("allValidWells").InnerText = "A1,B1,C1,D1,E1,F1,G1,H1,A2,B2,C2,D2,E2,F2,G2,H2,A3,B3,C3,D3,E3,F3,G3,H3,A4,B4,C4,D4,E4,F4,G4,H4,A5,B5,C5,D5,E5,F5,G5,H5,A6,B6,C6,D6,E6,F6,G6,H6,A7,B7,C7,D7,E7,F7,G7,H7,A8,B8,C8,D8,E8,F8,G8,H8,A9,B9,C9,D9,E9,F9,G9,H9,A10,B10,C10,D10,E10,F10,G10,H10,A11,B11,C11,D11,E11,F11,G11,H11,A12,B12,C12,D12,E12,F12,G12,H12";
                            //        }
                            //    }
                            //}

                            var platformNodeList = xmldoc.SelectSingleNode("root/env").SelectNodes("platform");
                            // wellstip恢复, 本方法重新执行
                            foreach (XmlNode platformNodeItem in platformNodeList)
                            {
                                string latticeId = platformNodeItem.SelectSingleNode("lattice_id").InnerText;
                                XmlNodeList labwareNode = platformNodeItem.SelectNodes("labware");
                                int countOfLabware = labwareNode.Count;
                                if (countOfLabware == 0)
                                {
                                    continue;
                                }
                                string labwareId = string.Empty;
                                string latticeNum = string.Empty;
                                var labwareXml = platformNodeItem.SelectSingleNode("labware[@id=" + (countOfLabware).ToString() + "]");
                                if (labwareXml != null)
                                {

                                    labwareId = labwareXml.SelectSingleNode("labware_id").InnerText;

                                    latticeNum = labwareXml.SelectSingleNode("labware_sname").InnerText;
                                    if (labwareId == null || labwareId.Equals(""))
                                    {
                                        continue;
                                    }
                                }
                                else
                                {
                                    continue;
                                }

                                Labware labWare = LabwareDB.GetLabware(labwareId);

                                // 全清除
                                {
                                    if (labWare.labware_type_id != EnumManagement.GetEnumValue(ConsumableTypeEnum.TipsBox).ToString())  // 吸头盒
                                    {
                                        continue;
                                    }

                                    latticeId = ControlCom.GetLatticeId(Convert.ToInt32(latticeId)).ToString();

                                    //查找出此设备所有枪对应的板位id
                                    int armCount = Shared.DeviceArmList.Where(x => x.arm_type.Equals(1)).ToList().Count;
                                    List<DeviceArm> deviceArms = Shared.DeviceArmList.Where(x => x.arm_type.Equals(1)).ToList();
                                    string[] strPos = new string[armCount];
                                    string baseLatticeId = latticeId;
                                    for (int i = 0; i < armCount; i++)
                                    {
                                        TabletopTemplate tabletopTemplate = TabletopTemplateDB.GetCurrentAppTabletopTemplateCollectionFromdb();  //增加台面模板判断
                                        if (tabletopTemplate == null)
                                        {
                                            latticeId = ControlCom.GetLatticeId(Convert.ToInt32(baseLatticeId)).ToString();
                                        }
                                        else
                                        {
                                            string latticeNumber = "P" + baseLatticeId;
                                            latticeId = LatticeDB.GetLatticeDataByLatticeNumAndTempIdFromdb(latticeNumber, Convert.ToInt32(deviceArms[i].device_arm_id), Shared.SoftwareInformation.software_device_number, tabletopTemplate.tabletopid).lattice_id;
                                        }

                                        var selUsedWellLattice = RunWnd.currentIsUsedWellLattice.Where(x => x.dropdown_id.Equals(latticeId));
                                        if (selUsedWellLattice.Any())
                                        {
                                            List<DropdownName> usedWellLatticeList = selUsedWellLattice.ToList();

                                            // 清除当前被使用过的板位和孔对象
                                            foreach (var selUsedWellLatticeItem in usedWellLatticeList)
                                            {
                                                RunWnd.currentIsUsedWellLattice.Remove(selUsedWellLatticeItem);
                                            }
                                        }
                                    }

                                    // 设置有效孔位
                                    string validWells = ComUtility.GetValidWells((int)labWare.number_row, (int)labWare.number_column);
                                    labwareXml.SelectSingleNode("allValidWells").InnerText = labwareXml.SelectSingleNode("residueValidWells").InnerText = validWells;

                                }
                            }

                            xmldoc.Save(fileName);
                        }
                    }
                }


                PlsToolTipWin plsToolTipWin = new PlsToolTipWin("清除成功！");
                plsToolTipWin.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                plsToolTipWin.Height = 450;
                plsToolTipWin.Width = 600;
                plsToolTipWin.btnCancel.Visibility = Visibility.Hidden;
                SolidColorBrush mybtn1_Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(0, 0, 0, 0));
                plsToolTipWin.Background = (System.Windows.Media.Brush)mybtn1_Brush;
                plsToolTipWin.ShowDialog();
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("错误：" + ex.Message.ToString());
            }
        }

        #region 设置可用通道
        private void tipsChannel_SelectedChangedEvent(object sender, EventArgs e)
        {
            
        }
        #endregion

        #region 观察者模式更新所有应用的通道设置
        // 观察者模式更新所有应用的通道设置
        public List<IDeviceArmObserver> observers = new List<IDeviceArmObserver>();

        public void AddObserver(IDeviceArmObserver ob)
        {
            observers.Add(ob);
        }

        public void RemoveObserver(IDeviceArmObserver ob)
        {
            observers.Remove(ob);
        }
        public void Update()
        {
            // 遍历订阅者列表进行通知
            foreach (IDeviceArmObserver ob in observers)
            {
                if (ob != null)
                {
                    ob.ReceiveAndUpdate();
                }
            }
        }
        #endregion

        private void tipsChannelDisOne_SelectedChangedEvent(object sender, EventArgs e)
        {
            //跟新通道进入数据库
            int[] Channels = tipsChannelDisOne.SelectedChannels.ToArray();
            string strChannel = String.Empty;
            for (int i = 0; i < Channels.Length; i++)
            {
                strChannel += Channels[i].ToString() + ",";
            }

            if (strChannel != String.Empty)
            {
                strChannel = strChannel.Substring(0, strChannel.Length - 1);
            }

            DeviceArm deviceArm = (DeviceArm)tipsChannelDisOne.Tag;//Shared.DeviceArmList.SingleOrDefault(x => x.software_information_id.Equals(Shared.SoftwareInformation.software_information_id) && x.arm_type.Equals(1));
            deviceArm.device_arm_property = strChannel;
            DeviceArmDB.UpdateDeviceIntodb(deviceArm);

            //跟新已经编辑的流程命令方法中的通道
            Update();
        }

        private void tipsChannelDisTwo_SelectedChangedEvent(object sender, EventArgs e)
        {
            //跟新通道进入数据库
            int[] Channels = tipsChannelDisTwo.SelectedChannels.ToArray();
            string strChannel = String.Empty;
            for (int i = 0; i < Channels.Length; i++)
            {
                strChannel += Channels[i].ToString() + ",";
            }

            if (strChannel != String.Empty)
            {
                strChannel = strChannel.Substring(0, strChannel.Length - 1);
            }
            DeviceArm deviceArm = (DeviceArm)tipsChannelDisTwo.Tag;//= Shared.DeviceArmList.SingleOrDefault(x => x.software_information_id.Equals(Shared.SoftwareInformation.software_information_id) && x.arm_type.Equals(1));
            deviceArm.device_arm_property = strChannel;
            DeviceArmDB.UpdateDeviceIntodb(deviceArm);

            //跟新已经编辑的流程命令方法中的通道
            Update();
        }

        private void tipsChannelDisThree_SelectedChangedEvent(object sender, EventArgs e)
        {
            //跟新通道进入数据库
            int[] Channels = tipsChannelDisThree.SelectedChannels.ToArray();
            string strChannel = String.Empty;
            for (int i = 0; i < Channels.Length; i++)
            {
                strChannel += Channels[i].ToString() + ",";
            }

            if (strChannel != String.Empty)
            {
                strChannel = strChannel.Substring(0, strChannel.Length - 1);
            }
            DeviceArm deviceArm=(DeviceArm)tipsChannelDisTwo.Tag;//= Shared.DeviceArmList.SingleOrDefault(x => x.software_information_id.Equals(Shared.SoftwareInformation.software_information_id) && x.arm_type.Equals(1));
            deviceArm.device_arm_property = strChannel;
            DeviceArmDB.UpdateDeviceIntodb(deviceArm);

            //跟新已经编辑的流程命令方法中的通道
            Update();
        }

        #region 泵排液
        bool isStartExecuteDispense = false;
        private async void btnDispense_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (isStartExecuteDispense)
                {
                    return;
                }
                AddLiquidMParamSH addLiquidMParamSH = new AddLiquidMParamSH();

                addLiquidMParamSH.armId = Convert.ToInt32(Shared.DeviceArmList.FirstOrDefault(x => x.arm_type.Equals(2)).device_arm_id);
                List<int> channelList = new List<int>();
                List<float> channelVolumes = new List<float>();
                if ((bool)cbxPumpNumber1.IsChecked)
                {
                    channelList.Add(1);
                    channelVolumes.Add((float)Convert.ToDouble(txtVolume1.Text));
                }
                if ((bool)cbxPumpNumber2.IsChecked)
                {
                    channelList.Add(2);
                    channelVolumes.Add((float)Convert.ToDouble(txtVolume2.Text));
                }
                if ((bool)cbxPumpNumber3.IsChecked)
                {
                    channelList.Add(3);
                    channelVolumes.Add((float)Convert.ToDouble(txtVolume3.Text));
                }
                if ((bool)cbxPumpNumber4.IsChecked)
                {
                    channelList.Add(4);
                    channelVolumes.Add((float)Convert.ToDouble(txtVolume4.Text));
                }

                int[] channels = new int[channelList.Count];
                float[] fVolumes = new float[channelList.Count];
                float[] xVals = new float[channelList.Count];
                float[] yVals = new float[channelList.Count];
                addLiquidMParamSH.channelId = channels;
                addLiquidMParamSH.channelCount = channelList.Count;

                //查询当前的垃圾桶
                List<Lattice> lattice = LatticeDB.GetTrashLatticeDataByIdFromdb(addLiquidMParamSH.armId.ToString(), Shared.SoftwareInformation.software_device_number);       // 获取当前垃圾桶台面板位信息

                for (int i = 0; i < channelList.Count; i++)
                {
                    channels[i] = channelList[i];
                    fVolumes[i] = channelVolumes[i];
                    xVals[i] = (float)lattice[0].lattice_X + 60f;
                    yVals[i] = (float)lattice[0].lattice_Y + 60f;

                }

                addLiquidMParamSH.volume = fVolumes;
                addLiquidMParamSH.xAxisVal = xVals;
                addLiquidMParamSH.yAxisVal = yVals;
                addLiquidMParamSH.zAxisVal = (float)lattice[0].lattice_Z - 50f;
                addLiquidMParamSH.speed = 1000;
                addLiquidMParamSH.addLiquidAfterDelay = 500;
                addLiquidMParamSH.basezAxisVal = 0;
                PumpDispenseBll pumpDispenseBll = new PumpDispenseBll();

                
                HxResult ret = new HxResult();
                PlsToolTipWin plsToolTipWin = null;
                if (MethodAction.Instance!=null&&!MethodAction.Instance.IsHome)
                {
                    plsToolTipWin = new PlsToolTipWin(Properties.SettingsTextResource.strSystemHomeTipInfo);
                    plsToolTipWin.btnCancel.Visibility = Visibility.Hidden;
                    plsToolTipWin.ShowDialog();
                    return;
                }
                Mouse.OverrideCursor = Cursors.Wait;
                Task task = new Task(() =>
                {
                    ret = pumpDispenseBll.ExecutePumpDispense(addLiquidMParamSH, false);
                });

                task.Start();
                task.Wait();

                string strMsg = string.Empty;
                
                if (ret.Result != ResultType.Success)
                {
                    if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                    {
                        LoggerRunHelper.InfoLog("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【泵排出空气】" + Properties.MachineRunResource.strProgress.ToString() + Properties.RunDispenseResource.strDispenseFail.ToString() + ret.AlarmInfo + " 在垃圾桶板位");
                        strMsg = "【泵排出空气】" + Properties.MachineRunResource.strProgress.ToString() + Properties.RunDispenseResource.strDispenseFail.ToString() + ret.AlarmInfo + " 在垃圾桶板位";
                    }
                    else
                    {
                        LoggerRunHelper.InfoLog("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【泵排出空气】progress: dispense of pump was failed on trash bin lattice! Error info：" + ret.AlarmInfo);
                        strMsg = "【泵排出空气】progress: dispense of pump was failed on trash bin lattice! Error info：" + ret.AlarmInfo;
                    }


                }
                else
                {
                    if (Shared.SoftwareInformation.currentculture.Equals("zh-CN"))
                    {
                        LoggerRunHelper.InfoLog("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【泵排出空气】" + Properties.MachineRunResource.strProgress.ToString() + Properties.RunDispenseResource.strDispenseSuccess.ToString() + "在垃圾桶板位");
                        strMsg = "【泵排出空气】" + Properties.MachineRunResource.strProgress.ToString() + Properties.RunDispenseResource.strDispenseSuccess.ToString() + "在垃圾桶板位";
                    }
                    else
                    {
                        LoggerRunHelper.InfoLog("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【泵排出空气】progress:dispense of pump was successful on trash bin lattice!");
                        strMsg = "【泵排出空气】progress:dispense of pump was successful on trash bin lattice!";
                    }
                }
                Mouse.OverrideCursor = Cursors.Arrow;
                //System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
                //{
                    plsToolTipWin = new PlsToolTipWin(strMsg);
                    plsToolTipWin.btnCancel.Visibility = Visibility.Hidden;
                    isStartExecuteDispense = true;
                    plsToolTipWin.ShowDialog();
                //}));

                
                Mouse.OverrideCursor = Cursors.Arrow;
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }
            finally
            {
                isStartExecuteDispense = false;
                Mouse.OverrideCursor = Cursors.Arrow;
            }
        }
        #endregion

        private void txtVolume1_TextChanged(object sender, System.Windows.Controls.TextChangedEventArgs e)
        {

        }

        private void txtVolume2_TextChanged(object sender, System.Windows.Controls.TextChangedEventArgs e)
        {

        }

        private void txtVolume3_TextChanged(object sender, System.Windows.Controls.TextChangedEventArgs e)
        {

        }

        private void txtVolume4_TextChanged(object sender, System.Windows.Controls.TextChangedEventArgs e)
        {

        }
    }

    public class VolumeVal
    {
        public float Volume1 { get; set; }
        public float Volume2 { get; set; }
        public float Volume3 { get; set; }
        public float Volume4 { get; set; }
    }
}