using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Input;

using OpenSEMI.ClientBase;
using OpenSEMI.ClientBase.Command;
using MECF.Framework.Common.RecipeCenter;
using RecipeEditorLib.DGExtension.CustomColumn;
using Caliburn.Micro.Core;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using MECF.Framework.Common.OperationCenter;
using System.Windows.Data;
using System;

namespace FurnaceUI.Client.Dialog
{
    public class N2PurgeSelectDialogViewModel : DialogViewModel<string>
    {
        #region properties
        private string _SelectedName;
        public string SelectedName
        {
            get { return _SelectedName; }
            set { _SelectedName = value; }
        }

        public Visibility TransferRoomVisible { get; set; } = Visibility.Collapsed;

        public Visibility FOUPOpenVisible { get; set; } = Visibility.Collapsed;

        public Visibility O2DetectorVisible { get; set; } = Visibility.Collapsed;

        public Visibility ClampOFFVisible { get; set; } = Visibility.Collapsed;

        public Visibility FurnaceOpenVisible { get; set; } = Visibility.Collapsed;



        public Visibility OperationCheckVisible { get; set; } = Visibility.Collapsed;

        public Visibility O2DensityQuickDownVisible { get; set; } = Visibility.Collapsed;

        public Visibility FoupEnterVisible { get; set; } = Visibility.Collapsed;

        public Visibility WaferChargeVisible { get; set; } = Visibility.Collapsed;

        public Visibility BoatLoadVisible { get; set; } = Visibility.Collapsed;

        public Visibility FoupInhibitAfterVisible { get; set; } = Visibility.Collapsed;

        public Visibility BoatUnloadVisible { get; set; } = Visibility.Collapsed;

        public Visibility BoatUnloadPreVisible { get; set; } = Visibility.Collapsed;

        public Visibility WaferCoolingVisible { get; set; } = Visibility.Collapsed;

        public Visibility WaferDishargeVisible { get; set; } = Visibility.Collapsed;

        #endregion

        #region Command
        private ICommand _BtnSelectCommand;
        public ICommand SelectCommand
        {
            get
            {
                if (this._BtnSelectCommand == null)
                    this._BtnSelectCommand = new BaseCommand<EventCommandParameter<object, RoutedEventArgs>>((EventCommandParameter<object, RoutedEventArgs> arg) => this.OnSelectCommand(arg));
                return this._BtnSelectCommand;
            }
        }

        private ICommand _BtnCancelCommand;
        public ICommand CancelCommand
        {
            get
            {
                if (this._BtnCancelCommand == null)
                    this._BtnCancelCommand = new BaseCommand<EventCommandParameter<object, RoutedEventArgs>>((EventCommandParameter<object, RoutedEventArgs> arg) => this.OnCancelCommand(arg));
                return this._BtnCancelCommand;
            }
        }

        private ICommand _ListViewDoubleClick;
        public ICommand ListViewDoubleClick
        {
            get
            {
                if (this._ListViewDoubleClick == null)
                    this._ListViewDoubleClick = new BaseCommand<EventCommandParameter<object, RoutedEventArgs>>((EventCommandParameter<object, RoutedEventArgs> arg) => this.OnListViewDoubleClick(arg));
                return this._ListViewDoubleClick;
            }
        }
        #endregion

        #region Function

        public N2PurgeSelectDialogViewModel(string ButtonPara)
        {
            switch (ButtonPara)
            {
                case "TransferRoomVisible":
                    TransferRoomVisible = Visibility.Visible;
                    break;
                case "FOUPOpenVisible":
                    FOUPOpenVisible = Visibility.Visible;
                    break;
                case "O2DetectorVisible":
                    O2DetectorVisible = Visibility.Visible;
                    break;
                case "ClampOFFVisible":
                    ClampOFFVisible = Visibility.Visible;
                    break;
                case "FurnaceOpenVisible":
                    FurnaceOpenVisible = Visibility.Visible;
                    break;

                case "OperationCheckVisible":
                    OperationCheckVisible = Visibility.Visible;
                    break;
                case "O2DensityQuickDownVisible":
                    O2DensityQuickDownVisible = Visibility.Visible;
                    break;
                case "FoupEnterVisible":
                    FoupEnterVisible = Visibility.Visible;
                    break;
                case "WaferChargeVisible":
                    WaferChargeVisible = Visibility.Visible;
                    break;
                case "BoatLoadVisible":
                    BoatLoadVisible = Visibility.Visible;
                    break;

                case "FoupInhibitAfterVisible":
                    FoupInhibitAfterVisible = Visibility.Visible;
                    break;
                case "BoatUnloadVisible":
                    BoatUnloadVisible = Visibility.Visible;
                    break;
                case "BoatUnloadPreVisible":
                    BoatUnloadPreVisible = Visibility.Visible;
                    break;
                case "WaferCoolingVisible":
                    WaferCoolingVisible = Visibility.Visible;
                    break;
                case "WaferDishargeVisible":
                    WaferDishargeVisible = Visibility.Visible;
                    break;

            }
        }

        protected override void OnInitialize()
        {
            base.OnInitialize();


            this.DisplayName = "Select Dialog";
        }



        public double TransferRoomArrivalWaitTime
        {
            get { return _transferRoomArrivalWaitTime; }
            set
            {
                _transferRoomArrivalWaitTime = value;
                NotifyOfPropertyChange(() => TransferRoomArrivalWaitTime);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.TransferRoomArrivalWaitTime", _transferRoomArrivalWaitTime);
            }
        }
        private double _transferRoomArrivalWaitTime;


        public double TransferRoomStableWaitTime
        {
            get { return _transferRoomStableWaitTime; }
            set
            {
                _transferRoomStableWaitTime = value;
                NotifyOfPropertyChange(() => TransferRoomStableWaitTime);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.TransferRoomStableWaitTime", _transferRoomStableWaitTime);
            }
        }
        private double _transferRoomStableWaitTime;



        public double FOUPOpenerArrivalWaitTime
        {
            get { return _fOUPOpenerArrivalWaitTime; }
            set
            {
                _fOUPOpenerArrivalWaitTime = value;
                NotifyOfPropertyChange(() => FOUPOpenerArrivalWaitTime);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.FOUPOpenerArrivalWaitTime", _fOUPOpenerArrivalWaitTime);
            }
        }
        private double _fOUPOpenerArrivalWaitTime;


        public double FOUPOpenerStableWaitTime
        {
            get { return _fOUPOpenerStableWaitTime; }
            set
            {
                _fOUPOpenerStableWaitTime = value;
                NotifyOfPropertyChange(() => FOUPOpenerStableWaitTime);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.FOUPOpenerStableWaitTime", _fOUPOpenerStableWaitTime);
            }
        }
        private double _fOUPOpenerStableWaitTime;


        public double O2DetectorTransferRoomToFOUPTime
        {
            get { return _o2DetectorTransferRoomToFOUPTime; }
            set
            {
                _o2DetectorTransferRoomToFOUPTime = value;
                NotifyOfPropertyChange(() => O2DetectorTransferRoomToFOUPTime);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.O2DetectorTransferRoomToFOUPTime", _o2DetectorTransferRoomToFOUPTime);
            }
        }
        private double _o2DetectorTransferRoomToFOUPTime;

        public double O2DetectorFOUPToTransferRoomTime
        {
            get { return _o2DetectorFOUPToTransferRoomTime; }
            set
            {
                _o2DetectorFOUPToTransferRoomTime = value;
                NotifyOfPropertyChange(() => O2DetectorFOUPToTransferRoomTime);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.O2DetectorFOUPToTransferRoomTime", _o2DetectorFOUPToTransferRoomTime);
            }
        }
        private double _o2DetectorFOUPToTransferRoomTime;


        public double O2DetectorFOUPToFOUPTime
        {
            get { return _o2DetectorFOUPToFOUPTime; }
            set
            {
                _o2DetectorFOUPToFOUPTime = value;
                NotifyOfPropertyChange(() => O2DetectorFOUPToFOUPTime);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.O2DetectorFOUPToFOUPTime", _o2DetectorFOUPToFOUPTime);
            }
        }
        private double _o2DetectorFOUPToFOUPTime;










        #region FoupEnter

        public bool LAN2PurgeFoupEnterEnable
        {
            get { return _laN2PurgeFoupEnterEnable; }
            set
            {
                _laN2PurgeFoupEnterEnable = value;
                NotifyOfPropertyChange(() => LAN2PurgeFoupEnterEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.FoupEnter.TransferRoomN2PurgeEnable", _laN2PurgeFoupEnterEnable);
            }
        }
        private bool _laN2PurgeFoupEnterEnable;
        public bool FOUPN2PurgeFoupEnterEnable
        {
            get { return _fOUPN2PurgeFoupEnterEnable; }
            set
            {
                _fOUPN2PurgeFoupEnterEnable = value;
                NotifyOfPropertyChange(() => FOUPN2PurgeFoupEnterEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.FoupEnter.FOUPN2PurgeEnable", _fOUPN2PurgeFoupEnterEnable);
            }
        }
        private bool _fOUPN2PurgeFoupEnterEnable;


        #endregion
        #region WaferCharge
        public bool FOUPN2PurgeChargeEnable
        {
            get { return _fOUPN2PurgeChargeEnable; }
            set
            {
                _fOUPN2PurgeChargeEnable = value;
                NotifyOfPropertyChange(() => FOUPN2PurgeChargeEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.WaferCharge.FOUPN2PurgeEnable", _fOUPN2PurgeChargeEnable);
            }
        }
        private bool _fOUPN2PurgeChargeEnable;

        public bool WaferChargeTransferRoomN2PurgeEnable
        {
            get { return _waferChargeTransferRoomN2PurgeEnable; }
            set
            {
                _waferChargeTransferRoomN2PurgeEnable = value;
                NotifyOfPropertyChange(() => WaferChargeTransferRoomN2PurgeEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.WaferCharge.TransferRoomN2PurgeEnable", _waferChargeTransferRoomN2PurgeEnable);
            }
        }
        private bool _waferChargeTransferRoomN2PurgeEnable;


        public bool WaferChargeTransferRoomO2DensityCheckEnable
        {
            get { return _waferChargeTransferRoomO2DensityCheckEnable; }
            set
            {
                _waferChargeTransferRoomO2DensityCheckEnable = value;
                NotifyOfPropertyChange(() => WaferChargeTransferRoomO2DensityCheckEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.WaferCharge.TransferRoomO2DensityCheckEnable", _waferChargeTransferRoomO2DensityCheckEnable);
            }
        }
        private bool _waferChargeTransferRoomO2DensityCheckEnable;

        public bool WaferChargeTransferRoomO2DensityKeepEnable
        {
            get { return _waferChargeTransferRoomO2DensityKeepEnable; }
            set
            {
                _waferChargeTransferRoomO2DensityKeepEnable = value;
                NotifyOfPropertyChange(() => WaferChargeTransferRoomO2DensityKeepEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.WaferCharge.TransferRoomO2DensityKeepEnable", _waferChargeTransferRoomO2DensityKeepEnable);
            }
        }
        private bool _waferChargeTransferRoomO2DensityKeepEnable;

        #endregion
        #region WaferDisCharge
        public bool WaferDisChargeTransferRoomN2PurgeEnable
        {
            get { return _waferDisChargeTransferRoomN2PurgeEnable; }
            set
            {
                _waferDisChargeTransferRoomN2PurgeEnable = value;
                NotifyOfPropertyChange(() => WaferDisChargeTransferRoomN2PurgeEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.WaferDischarge.TransferRoomN2PurgeEnable", _waferDisChargeTransferRoomN2PurgeEnable);
            }
        }
        private bool _waferDisChargeTransferRoomN2PurgeEnable;
        public bool WaferDisChargeFOUPN2PurgeEnable
        {
            get { return _waferDisChargeFOUPN2PurgeEnable; }
            set
            {
                _waferDisChargeFOUPN2PurgeEnable = value;
                NotifyOfPropertyChange(() => WaferDisChargeFOUPN2PurgeEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.WaferDischarge.FOUPN2PurgeEnable", _waferDisChargeFOUPN2PurgeEnable);
            }
        }
        private bool _waferDisChargeFOUPN2PurgeEnable;
        public bool WaferDisChargeTransferRoomO2DensityKeepEnable
        {
            get { return _waferDisChargeTransferRoomO2DensityKeepEnable; }
            set
            {
                _waferDisChargeTransferRoomO2DensityKeepEnable = value;
                NotifyOfPropertyChange(() => WaferDisChargeTransferRoomO2DensityKeepEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.WaferDischarge.TransferRoomO2DensityKeepEnable", _waferDisChargeTransferRoomO2DensityKeepEnable);
            }
        }
        private bool _waferDisChargeTransferRoomO2DensityKeepEnable;

        public bool WaferDisChargeTransferRoomO2DensityCheckEnable
        {
            get { return _waferDisChargeTransferRoomO2DensityCheckEnable; }
            set
            {
                _waferDisChargeTransferRoomO2DensityCheckEnable = value;
                NotifyOfPropertyChange(() => WaferDisChargeTransferRoomO2DensityCheckEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.WaferDischarge.TransferRoomO2DensityCheckEnable", _waferDisChargeTransferRoomO2DensityCheckEnable);
            }
        }
        private bool _waferDisChargeTransferRoomO2DensityCheckEnable;



        #endregion

        #region BoatLoad
        public bool BoatLoadTransferRoomO2DensityCheckEnable
        {
            get { return _boatLoadTransferRoomO2DensityCheckEnable; }
            set
            {
                _boatLoadTransferRoomO2DensityCheckEnable = value;
                NotifyOfPropertyChange(() => BoatLoadTransferRoomO2DensityCheckEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.BoatLoad.TransferRoomO2DensityCheckEnable", _boatLoadTransferRoomO2DensityCheckEnable);
            }
        }
        private bool _boatLoadTransferRoomO2DensityCheckEnable;


        public bool BoatLoadTransferRoomN2PurgeEnable
        {
            get { return _boatLoadTransferRoomN2PurgeEnable; }
            set
            {
                _boatLoadTransferRoomN2PurgeEnable = value;
                NotifyOfPropertyChange(() => BoatLoadTransferRoomN2PurgeEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.BoatLoad.TransferRoomN2PurgeEnable", _boatLoadTransferRoomN2PurgeEnable);
            }
        }
        private bool _boatLoadTransferRoomN2PurgeEnable;

        #endregion
        #region BoatUnload

        public bool BoatUnLoadTransferRoomO2DensityCheckEnable
        {
            get { return _boatUnLoadTransferRoomO2DensityCheckEnable; }
            set
            {
                _boatUnLoadTransferRoomO2DensityCheckEnable = value;
                NotifyOfPropertyChange(() => BoatUnLoadTransferRoomO2DensityCheckEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.BoatUnLoad.TransferRoomO2DensityCheckEnable", _boatUnLoadTransferRoomO2DensityCheckEnable);
            }
        }
        private bool _boatUnLoadTransferRoomO2DensityCheckEnable;
        public bool BoatUnLoadTransferRoomN2PurgeEnable
        {
            get { return _boatUnLoadTransferRoomN2PurgeEnable; }
            set
            {
                _boatUnLoadTransferRoomN2PurgeEnable = value;
                NotifyOfPropertyChange(() => BoatUnLoadTransferRoomN2PurgeEnable);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", "PM1.N2Purge.BoatUnLoad.TransferRoomN2PurgeEnable", _boatUnLoadTransferRoomN2PurgeEnable);
            }
        }
        private bool _boatUnLoadTransferRoomN2PurgeEnable;
        #endregion
        protected override void OnActivate()
        {
            base.OnActivate();
            string valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.TransferRoomArrivalWaitTime");
            if (!string.IsNullOrEmpty(valueConfig) && double.TryParse(valueConfig, out double transferRoomArrivalWaitTime))
            {
                _transferRoomArrivalWaitTime = transferRoomArrivalWaitTime;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.TransferRoomStableWaitTime");
            if (!string.IsNullOrEmpty(valueConfig) && double.TryParse(valueConfig, out double transferRoomStableWaitTime))
            {
                _transferRoomStableWaitTime = transferRoomStableWaitTime;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.FOUPOpenerArrivalWaitTime");
            if (!string.IsNullOrEmpty(valueConfig) && double.TryParse(valueConfig, out double fOUPOpenerArrivalWaitTime))
            {
                _fOUPOpenerArrivalWaitTime = fOUPOpenerArrivalWaitTime;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.FOUPOpenerStableWaitTime");
            if (!string.IsNullOrEmpty(valueConfig) && double.TryParse(valueConfig, out double fOUPOpenerStableWaitTime))
            {
                _fOUPOpenerStableWaitTime = fOUPOpenerStableWaitTime;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.O2DetectorTransferRoomToFOUPTime");
            if (!string.IsNullOrEmpty(valueConfig) && double.TryParse(valueConfig, out double o2DetectorTransferRoomToFOUPTime))
            {
                _o2DetectorTransferRoomToFOUPTime = o2DetectorTransferRoomToFOUPTime;

            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.O2DetectorFOUPToTransferRoomTime");
            if (!string.IsNullOrEmpty(valueConfig) && double.TryParse(valueConfig, out double o2DetectorFOUPToTransferRoomTime))
            {
                _o2DetectorFOUPToTransferRoomTime = o2DetectorFOUPToTransferRoomTime;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.O2DetectorFOUPToFOUPTime");
            if (!string.IsNullOrEmpty(valueConfig) && double.TryParse(valueConfig, out double o2DetectorFOUPToFOUPTime))
            {
                _o2DetectorFOUPToFOUPTime = o2DetectorFOUPToFOUPTime;
            }




            #region FoupEnter
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.FoupEnter.FOUPN2PurgeEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool foupEnterFOUPN2PurgeEnable))
            {
                _fOUPN2PurgeFoupEnterEnable = foupEnterFOUPN2PurgeEnable;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.FoupEnter.TransferRoomN2PurgeEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool foupEnterTransferRoomN2PurgeEnable))
            {
                _laN2PurgeFoupEnterEnable = foupEnterTransferRoomN2PurgeEnable;
            }
            #endregion

            #region WaferCharge
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.WaferCharge.TransferRoomN2PurgeEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool transferRoomN2PurgeChargeEnable))
            {
                _waferChargeTransferRoomN2PurgeEnable = transferRoomN2PurgeChargeEnable;
            }

            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.WaferCharge.TransferRoomO2DensityCheckEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool transferRoomO2DensityCheckChargeEnable))
            {
                _waferChargeTransferRoomO2DensityCheckEnable = transferRoomO2DensityCheckChargeEnable;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.WaferCharge.TransferRoomO2DensityKeepEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool transferRoomO2DensityKeepChargeEnable))
            {
                
                _waferChargeTransferRoomO2DensityKeepEnable = transferRoomO2DensityKeepChargeEnable;
            }

            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.WaferCharge.FOUPN2PurgeEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool fOUPN2PurgeChargeEnable))
            {
                _fOUPN2PurgeChargeEnable = fOUPN2PurgeChargeEnable;
            }

            #endregion
            #region WaferDisCharge
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.WaferDischarge.TransferRoomN2PurgeEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool waferDischargetransferRoomN2PurgeDischargeEnable))
            {
                _waferDisChargeTransferRoomN2PurgeEnable = waferDischargetransferRoomN2PurgeDischargeEnable;
            }

            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.WaferDischarge.TransferRoomO2DensityCheckEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool waferDischargeTransferRoomO2DensityCheckEnable))
            {
                _waferDisChargeTransferRoomO2DensityCheckEnable = waferDischargeTransferRoomO2DensityCheckEnable;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.WaferDischarge.TransferRoomO2DensityKeepEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool waferDisChargeTransferRoomO2DensityKeepDischargeEnable))
            {
                _waferDisChargeTransferRoomO2DensityKeepEnable = waferDisChargeTransferRoomO2DensityKeepDischargeEnable;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.WaferDischarge.FOUPN2PurgeEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool waferDischargeFOUPN2PurgeDischargeEnable))
            {
                _waferDisChargeFOUPN2PurgeEnable = waferDischargeFOUPN2PurgeDischargeEnable;
            }


            #endregion

            #region BoatLoad
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.BoatLoad.TransferRoomO2DensityCheckEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool boatLoadTransferRoomO2DensityCheckEnable))
            {
                _boatLoadTransferRoomO2DensityCheckEnable = boatLoadTransferRoomO2DensityCheckEnable;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.BoatLoad.TransferRoomN2PurgeEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool boatLoadtransferRoomN2PurgeEnable))
            {
                _boatLoadTransferRoomN2PurgeEnable = boatLoadtransferRoomN2PurgeEnable;
            }

            #endregion
            #region BoatUnload
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.BoatUnLoad.TransferRoomN2PurgeEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool boatUnLoadtransferRoomN2PurgeEnable))
            {
                _boatUnLoadTransferRoomN2PurgeEnable = boatUnLoadtransferRoomN2PurgeEnable;
            }
            valueConfig = SystemConfigProvider.Instance.GetValueByName("PM1.N2Purge.BoatUnLoad.TransferRoomO2DensityCheckEnable");
            if (!string.IsNullOrEmpty(valueConfig) && bool.TryParse(valueConfig, out bool boatUnLoadTransferRoomO2DensityCheckEnable))
            {
                _boatUnLoadTransferRoomO2DensityCheckEnable = boatUnLoadTransferRoomO2DensityCheckEnable;
            }
            #endregion

        }

        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
        }

        private void OnSelectCommand(EventCommandParameter<object, RoutedEventArgs> arg)
        {
            DialogResult = SelectedName;
            IsCancel = false;
            TryClose(true);
        }

        private void OnListViewDoubleClick(EventCommandParameter<object, RoutedEventArgs> arg)
        {
            if (arg != null)
            {
                this.DialogResult = SelectedName;
                IsCancel = false;
                TryClose(true);
            }
        }

        private void OnCancelCommand(EventCommandParameter<object, RoutedEventArgs> arg)
        {
            IsCancel = true;
            TryClose(false);
        }
        #endregion
    }


    public class InverseBoolConverter : IValueConverter
    {
        //源转目标
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (value is bool)
            {
                return !(bool)value;
            }
            return value;
        }
        //目标转源
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (value is bool)
            {
                return !(bool)value;
            }
            return value;
        }
    }
}