FurnaceELK/Furnace/FurnaceUI/Views/Operations/Maintenances/ManualSetViewModel.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Caliburn.Micro;
using Caliburn.Micro.Core;
using FurnaceUI.Client;
using FurnaceUI.Common;
using FurnaceUI.Models;
using FurnaceUI.Views.Editors;
using FurnaceUI.Views.Operations;
using FurnaceUI.Views.Parameter;
using FurnaceUI.Views.Status;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using MECF.Framework.UI.Client.ClientBase;
using OpenSEMI.ClientBase;
using OpenSEMI.Ctrlib.Controls;
using RecipeEditorLib.RecipeModel.Params;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace FurnaceUI.Views.Recipes
{
    public class ManualSetViewModel : FurnaceUIViewModelBase
    {
        [Subscription("PM1.CurrentAuxData")]
        public List<AITAuxData> AUXDetailDatas { get; set; }
        public string DefaultUnit { get; set; }

        #region MFCs
        [Subscription("PM1.MFC1.DeviceData")]
        public AITMfcData MFC1Data { get; set; }
        [Subscription("PM1.MFC2.DeviceData")]
        public AITMfcData MFC2Data { get; set; }
        [Subscription("PM1.MFC3.DeviceData")]
        public AITMfcData MFC3Data { get; set; }
        [Subscription("PM1.MFC4.DeviceData")]
        public AITMfcData MFC4Data { get; set; }
        [Subscription("PM1.MFC5.DeviceData")]
        public AITMfcData MFC5Data { get; set; }
        [Subscription("PM1.MFC6.DeviceData")]
        public AITMfcData MFC6Data { get; set; }
        [Subscription("PM1.MFC7.DeviceData")]
        public AITMfcData MFC7Data { get; set; }
        [Subscription("PM1.MFC8.DeviceData")]
        public AITMfcData MFC8Data { get; set; }
        [Subscription("PM1.MFC9.DeviceData")]
        public AITMfcData MFC9Data { get; set; }
        [Subscription("PM1.MFC10.DeviceData")]
        public AITMfcData MFC10Data { get; set; }
        [Subscription("PM1.MFC11.DeviceData")]
        public AITMfcData MFC11Data { get; set; }
        [Subscription("PM1.MFC12.DeviceData")]
        public AITMfcData MFC12Data { get; set; }
        [Subscription("PM1.MFC13.DeviceData")]
        public AITMfcData MFC13Data { get; set; }
        [Subscription("PM1.MFC14.DeviceData")]
        public AITMfcData MFC14Data { get; set; }
        [Subscription("PM1.MFC15.DeviceData")]
        public AITMfcData MFC15Data { get; set; }
        [Subscription("PM1.MFC16.DeviceData")]
        public AITMfcData MFC16Data { get; set; }
        [Subscription("PM1.MFC17.DeviceData")]
        public AITMfcData MFC17Data { get; set; }
        [Subscription("PM1.MFC31.DeviceData")]
        public AITMfcData MFC31Data { get; set; }
        [Subscription("PM1.MFC32.DeviceData")]
        public AITMfcData MFC32Data { get; set; }
        [Subscription("PM1.MFC51.DeviceData")]
        public AITMfcData MFC51Data { get; set; }
        #endregion
        [Subscription("PM1.EditRecipeStepNo")]
        public int EditRecipeStepNo { get; set; }
        [Subscription("PM1.EditRecipeName")]
        public string EditRecipeName { get; set; }

        [Subscription("PM1.EditRecipeStepName")]
        public string EditRecipeStepName { get; set; }

        private int ControlMode = 1;

        private UIElement _parent;

        [Subscription("System.HeaterU.DeviceData")]
        public AITHeaterData HeaterUData { get; set; }
        [Subscription("System.HeaterCU.DeviceData")]
        public AITHeaterData HeaterCUData { get; set; }
        [Subscription("System.HeaterC.DeviceData")]
        public AITHeaterData HeaterCData { get; set; }
        [Subscription("System.HeaterCL.DeviceData")]
        public AITHeaterData HeaterCLData { get; set; }
        [Subscription("System.HeaterL.DeviceData")]
        public AITHeaterData HeaterLData { get; set; }
        public AITHeaterData BottomHeaterData => HeaterLData;
        public AITHeaterData CenterBottomHeaterData => HeaterCLData;
        public AITHeaterData CenterHeaterData => HeaterCData;
        public AITHeaterData TopCenterHeaterData => HeaterCUData;
        public AITHeaterData TopHeaterData => HeaterUData;

        [Subscription("PM1.APC.DeviceData")]
        public AITAPCData APCData { get; set; }

        IWindowManager wm = IoC.Get<IWindowManager>();
        public bool IsPermission { get => this.Permission == 3; }
        private string _selectBtnName;

        public string SelectBtnName
        {
            get { return _selectBtnName; }
            set { _selectBtnName = value; this.NotifyOfPropertyChange(nameof(SelectBtnName)); }
        }

        private string _temperatureControlMode;
        public string TemperatureControlMode
        {
            get => _temperatureControlMode;
            set
            {
                _temperatureControlMode = value;
                NotifyOfPropertyChange(nameof(TemperatureControlMode));
            }
        }

        private string _temperatureCorrect;
        public string TemperatureCorrect
        {
            get => _temperatureCorrect;
            set
            {
                _temperatureCorrect = value;
                NotifyOfPropertyChange(nameof(TemperatureCorrect));
            }
        }

        private string _temperaturePID;
        public string TemperaturePID
        {
            get => _temperaturePID;
            set
            {
                _temperaturePID = value;
                NotifyOfPropertyChange(nameof(TemperaturePID));
            }
        }

        private string _loaderCommand = "";

        public string LoaderCommand
        {
            get => _loaderCommand;
            set
            {
                _loaderCommand = value;
                NotifyOfPropertyChange(nameof(LoaderCommand));
                NotifyOfPropertyChange(nameof(LoaderCommandIsSaved));
            }
        }

        public string OldLoaderCommand { get; set; } = "";

        public void SetParent(UIElement parent)
        {
            _parent = parent;
        }

        public bool LoaderCommandIsSaved
        {
            get => LoaderCommand == OldLoaderCommand;
        }

        #region"Loader Set Value"
        private Visibility _loaderSet3SpeedVisibility = Visibility.Hidden;

        public Visibility LoaderSet3SpeedVisibility
        {
            get => _loaderSet3SpeedVisibility;
            set
            {
                _loaderSet3SpeedVisibility = value;
                NotifyOfPropertyChange(nameof(LoaderSet3SpeedVisibility));
            }
        }

        private Visibility _loaderSetSpeedVisibility = Visibility.Hidden;

        public Visibility LoaderSetSpeedVisibility
        {
            get => _loaderSetSpeedVisibility;
            set
            {
                _loaderSetSpeedVisibility = value;
                NotifyOfPropertyChange(nameof(LoaderSetSpeedVisibility));
            }
        }

        private Visibility _loaderSetSpeedFloatVisibility = Visibility.Hidden;

        public Visibility LoaderSetSpeedFloatVisibility
        {
            get => _loaderSetSpeedFloatVisibility;
            set
            {
                _loaderSetSpeedFloatVisibility = value;
                NotifyOfPropertyChange(nameof(LoaderSetSpeedFloatVisibility));
            }
        }

        private string _pressCommand = "";

        public string PressCommand
        {
            get => _pressCommand;
            set
            {
                _pressCommand = value;
                NotifyOfPropertyChange(nameof(PressCommand));
                NotifyOfPropertyChange(nameof(PressCommandIsSaved));
            }
        }

        public string OldPressCommand { get; set; } = "";


        public bool PressCommandIsSaved
        {
            get => _pressCommand == OldPressCommand;
        }


        public void SetShowLoaderValuePanel(string selectedCmd)
        {
            switch (selectedCmd)
            {
                case "Boat Load":
                case "Boat Unload":
                    LoaderSet3SpeedVisibility = Visibility.Visible;
                    LoaderSetSpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedFloatVisibility = Visibility.Hidden;
                    break;
                case "Boat Rotate":
                    LoaderSet3SpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedFloatVisibility = Visibility.Visible;
                    break;
                case "Boat CAP2":
                    LoaderSet3SpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedVisibility = Visibility.Visible;
                    LoaderSetSpeedFloatVisibility = Visibility.Hidden;
                    break;
                case "Stop(Include R-axis)":
                case "Boat Rotate Stop":
                case "Boat Loader Home":
                case "None":
                case "NONE":
                    LoaderSet3SpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedFloatVisibility = Visibility.Hidden;
                    break;
                default:
                    break;
            }
        }

        public void SetLoaderValue(string selectedCmd, string Values)
        {
            switch (selectedCmd)
            {
                case "Boat Load":
                case "Boat Unload":
                    if (string.IsNullOrEmpty(Values)) return;
                    string[] list = Values.Split(';');
                    if (list.Length < 3) return;
                    Loader3Speed1 = int.Parse(list[0]);
                    Loader3Speed2 = int.Parse(list[1]);
                    Loader3Speed3 = int.Parse(list[2]);
                    break;
                case "Boat Rotate":
                    if (string.IsNullOrEmpty(Values)) return;
                    LoaderRPM = double.Parse(Values);
                    break;
                case "Boat CAP2":
                    if (string.IsNullOrEmpty(Values)) return;
                    LoaderSpeed = int.Parse(Values);
                    break;
                case "Stop(Include R-axis)":
                case "Boat Rotate Stop":
                case "Boat Loader Home":
                case "None":

                    break;
                default:
                    break;
            }
        }



        public string GetSaveLoaderValue(string selectedCmd)
        {
            switch (selectedCmd)
            {
                case "Boat Load":
                case "Boat Unload":
                    return $"{selectedCmd};{Loader3Speed1};{Loader3Speed2};{Loader3Speed3}";
                case "Boat Rotate":
                    return $"{selectedCmd};{LoaderRPM.ToString()}";
                case "Boat CAP2":
                    return $"{selectedCmd};{LoaderSpeed.ToString()}";
                case "Stop(Include R-axis)":
                case "Boat Rotate Stop":
                case "Boat Loader Home":
                case "None":
                    return $"{selectedCmd};";
                default:
                    return "";
            }
        }

        private int loader3Speed1 = 5;

        public int Loader3Speed1
        {
            get => loader3Speed1;
            set
            {
                loader3Speed1 = value;
                NotifyOfPropertyChange(nameof(Loader3Speed1));
            }
        }

        private int loader3Speed2 = 0;

        public int Loader3Speed2
        {
            get => loader3Speed2;
            set
            {
                loader3Speed2 = value;
                NotifyOfPropertyChange(nameof(Loader3Speed2));
            }
        }

        private int loader3Speed3 = 0;

        public int Loader3Speed3
        {
            get => loader3Speed3;
            set
            {
                loader3Speed3 = value;
                NotifyOfPropertyChange(nameof(Loader3Speed3));
            }
        }

        private double _loaderRPM = 0;

        public double LoaderRPM
        {
            get => _loaderRPM;
            set
            {
                _loaderRPM = value;
                NotifyOfPropertyChange(nameof(LoaderRPM));
            }
        }

        private int loaderSpeed = 0;

        public int LoaderSpeed
        {
            get => loaderSpeed;
            set
            {
                loaderSpeed = value;
                NotifyOfPropertyChange(nameof(LoaderSpeed));
            }
        }

        private void ClearLoaderSetValue()
        {
            Loader3Speed1 = 0;
            Loader3Speed2 = 0;
            Loader3Speed3 = 0;
            LoaderRPM = 0;
            LoaderSpeed = 0;
        }
        #endregion

        #region"PressVisibility"

        private Visibility _pressVisibility = Visibility.Hidden;

        public Visibility PressVisibility
        {
            get => _pressVisibility;
            set
            {
                _pressVisibility = value;
                NotifyOfPropertyChange(nameof(PressVisibility));
            }
        }


        private Visibility _pressSlowVacVisibility = Visibility.Hidden;

        public Visibility PressSlowVacVisibility
        {
            get => _pressSlowVacVisibility;
            set
            {
                _pressSlowVacVisibility = value;
                NotifyOfPropertyChange(nameof(PressSlowVacVisibility));
            }
        }

        private Visibility _pressValveAngleVisibility = Visibility.Hidden;

        public Visibility PressValveAngleVisibility
        {
            get => _pressValveAngleVisibility;
            set
            {
                _pressValveAngleVisibility = value;
                NotifyOfPropertyChange(nameof(PressValveAngleVisibility));
            }
        }


        private Visibility _pressWaitVisibility = Visibility.Hidden;

        public Visibility PressWaitVisibility
        {
            get => _pressWaitVisibility;
            set
            {
                _pressWaitVisibility = value;
                NotifyOfPropertyChange(nameof(PressWaitVisibility));
            }
        }

        private string _pressureCommand;

        public string PressureCommand
        {
            get => _pressureCommand;
            set
            {
                _pressureCommand = value;
            }
        }


        public void SetShowPressPanel(string selectedCmd)
        {
            switch (selectedCmd)
            {
                case "Press":
                case "Press2":
                    PressVisibility = Visibility.Visible;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "Slow Vac":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Visible;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "Valve Angle":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Visible;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "Full Open":
                case "Full Close":
                case "Hold":
                case "Zero Set":
                case "Cancel Zero":
                case "Home":
                case "None":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "WaitPressUp1":
                case "WaitPressDown1":
                case "WaitPressUp2":
                case "WaitPressDown2":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Visible;
                    break;
                default:
                    break;
            }
        }
        public void SetPressValue(string selectedCmd, string Values)
        {
            switch (selectedCmd)
            {
                case "Press":
                case "Press2":
                    if (string.IsNullOrEmpty(Values)) return;
                    string[] list = Values.Split(';');
                    if (list.Length < 2) return;
                    PressPID = list[0];
                    PressSet = double.Parse(list[1]);
                    break;
                case "Slow Vac":
                    if (string.IsNullOrEmpty(Values)) return;
                    PressSlowVacSet = double.Parse(Values);
                    break;
                case "Valve Angle":
                    if (string.IsNullOrEmpty(Values)) return;
                    PressValveAngleSet = double.Parse(Values);
                    break;
                case "Full Open":
                case "Full Close":
                case "Hold":
                case "Zero Set":
                case "Cancel Zero":
                    break;
                case "WaitPressUp1":
                case "WaitPressDown1":
                case "WaitPressUp2":
                case "WaitPressDown2":
                    if (string.IsNullOrEmpty(Values)) return;
                    PressWait = double.Parse(Values);
                    break;
                default:
                    break;
            }
        }

        public string GetSavePressValue(string selectedCmd)
        {
            switch (selectedCmd)
            {
                case "Press":
                case "Press2":
                    return $"{PressPID};{PressSet}";
                case "Slow Vac":
                    return PressSlowVacSet.ToString();
                case "Valve Angle":
                    return PressValveAngleSet.ToString();
                case "Full Open":
                case "Full Close":
                case "Hold":
                case "Zero Set":
                case "Cancel Zero":
                    return "";
                case "WaitPressUp1":
                case "WaitPressDown1":
                case "WaitPressUp2":
                case "WaitPressDown2":
                    return PressWait.ToString();
                default:
                    return "";
            }
        }


        private string _pressPID;

        public string PressPID
        {
            get => _pressPID;
            set
            {
                _pressPID = value;
                NotifyOfPropertyChange(nameof(PressPID));
            }
        }

        private double _pressSet;

        public double PressSet
        {
            get => _pressSet;
            set
            {
                _pressSet = value;
                NotifyOfPropertyChange(nameof(PressSet));
            }
        }

        private double _pressSlowVacSet;

        public double PressSlowVacSet
        {
            get => _pressSlowVacSet;
            set
            {
                _pressSlowVacSet = value;
                NotifyOfPropertyChange(nameof(PressSlowVacSet));
            }
        }

        private double _pressValveAngleSet;

        public double PressValveAngleSet
        {
            get => _pressValveAngleSet;
            set
            {
                _pressValveAngleSet = value;
                NotifyOfPropertyChange(nameof(PressValveAngleSet));
            }
        }

        private string _lowPressWait = "None";

        public string LowPressWait
        {
            get => _lowPressWait;
            set
            {
                _lowPressWait = value;
                NotifyOfPropertyChange(nameof(LowPressWait));
            }
        }

        private double _pressWait;

        public double PressWait
        {
            get => _pressWait;
            set
            {
                _pressWait = value;
                NotifyOfPropertyChange(nameof(PressWait));
            }
        }

        private void ClearPressSetValue()
        {
            PressPID = "None";
            PressSet = 0;
            PressSlowVacSet = 0;
            PressValveAngleSet = 0;
            LowPressWait = "None";
            PressWait = 0;
        }

        #endregion

        #region AlarmRecipe Visibility
        public bool IsAlarmReicpe => RecipeType.ToLower() == "alarm";
        public bool IsAbortReicpe => RecipeType.ToLower() == "abort";
        public bool IsSubReicpe => RecipeType.ToLower() == "sub";
        public bool IsTableVisibility => IsAlarmReicpe || IsAbortReicpe || IsSubReicpe;
        public bool IsRecipeHeaderVisibility => !IsTableVisibility;
        public bool IsVPDataListVisibility => !IsTableVisibility;
        public bool IsCombinationVisibility => !IsTableVisibility;
        #endregion

        private double _boatZAxisLimitSpeed;

        public double BoatZAxisLimitSpeed
        {
            get => _boatZAxisLimitSpeed;
            set
            {
                _boatZAxisLimitSpeed = value;
                NotifyOfPropertyChange(nameof(BoatZAxisLimitSpeed));
            }
        }
        private double _boatRAxisLimitSpeed;

        public double BoatRAxisLimitSpeed
        {
            get => _boatRAxisLimitSpeed;
            set
            {
                _boatRAxisLimitSpeed = value;
                NotifyOfPropertyChange(nameof(BoatRAxisLimitSpeed));
            }
        }
        private bool _noStandbyIsEnabled = false;
        public bool NoStandbyIsEnabled
        {
            get => _noStandbyIsEnabled;
            set
            {
                _noStandbyIsEnabled = value;
                NotifyOfPropertyChange(nameof(NoStandbyIsEnabled));
            }
        }

        private Visibility _standbyIsVisibility = Visibility.Visible;

        public Visibility StandbyIsVisibility
        {
            get => _standbyIsVisibility;
            set
            {
                _standbyIsVisibility = value;
                NotifyOfPropertyChange(nameof(StandbyIsVisibility));
            }
        }



        private string _selectedGasSetting2;
        public string SelectedGasSetting2
        {
            get
            {
                return _selectedGasSetting2;
            }
            set
            {
                _selectedGasSetting2 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting2));
            }
        }
        private string _selectedGasSetting3;
        public string SelectedGasSetting3
        {
            get
            {
                return _selectedGasSetting3;
            }
            set
            {
                _selectedGasSetting3 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting3));
            }
        }
        private string _selectedGasSetting4;
        public string SelectedGasSetting4
        {
            get
            {
                return _selectedGasSetting4;
            }
            set
            {
                _selectedGasSetting4 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting4));
            }
        }
        private string _selectedGasSetting5;
        public string SelectedGasSetting5
        {
            get
            {
                return _selectedGasSetting5;
            }
            set
            {
                _selectedGasSetting5 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting5));
            }
        }
        private string _selectedGasSetting6;
        public string SelectedGasSetting6
        {
            get
            {
                return _selectedGasSetting6;
            }
            set
            {
                _selectedGasSetting6 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting6));
            }
        }

        private List<ConfigNode> _ConfigNodes = new List<ConfigNode>();
        public List<ConfigNode> ConfigNodes
        {
            get { return _ConfigNodes; }
            set
            {
                _ConfigNodes = value;
                NotifyOfPropertyChange(nameof(ConfigNodes));
            }
        }

        public ObservableCollection<TempManualSetData> TempList { get; set; } = new ObservableCollection<TempManualSetData>();

        private ObservableCollection<MFCGasData> _mFCDatas = new ObservableCollection<MFCGasData>();

        public ObservableCollection<MFCGasData> MFCDataList
        {
            get => _mFCDatas;
            set
            {
                _mFCDatas = value;
                NotifyOfPropertyChange(nameof(MFCDataList));
            }
        }

        private string _pressureUnit;
        public string PressureUnit
        {
            get => _pressureUnit;
            set
            {
                _pressureUnit = value;
                NotifyOfPropertyChange(nameof(PressureUnit));
            }
        }

        public string RecipeType { get; set; }

        public ManualSetViewModel()
        {

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

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

            //InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorRecipeOK", "");
            LoadData();
            BoatZAxisLimitSpeed = (double)QueryDataClient.Instance.Service.GetConfig($"Boat.BoatElevatorServo.BoatZAxisLimitSpeed");
            BoatRAxisLimitSpeed = (double)QueryDataClient.Instance.Service.GetConfig($"Boat.BoatRotationServo.BoatRAxisLimitSpeed");

        }


        protected override void OnDeactivate(bool close)
        {
            base.OnDeactivate(close);
            //InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorPROCManualOK", "");
        }


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

        }

        private void LoadData()
        {
            firstUpdate = true;
        }


        //撤销修改
        public void RecipeIsChangeClick(object cmdName, object value)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch ((string)cmdName)
            {
                case "Alarm":

                    break;
                case "MFC":

                    break;
                case "Gas":

                    break;
                case "AUX":

                    break;
                case "Press":

                    break;
                case "Temp":

                    break;
                default:
                    break;
            }
        }

        public void TempSetClick(object sender)
        {
            string stSetValue = ShowNumberKeyboard(sender as Button, "", 1);
            foreach (var item in TempList)
            {

                item.Value = stSetValue;
                item.IsSetChanged = false;
            }
        }
        public Dictionary<string, bool> DictValve { get; set; } = new Dictionary<string, bool>();
        public Dictionary<string, string> DictMFC { get; set; } = new Dictionary<string, string>();

        public Dictionary<string, string> DictMFCRamp { get; set; } = new Dictionary<string, string>();
        public Dictionary<string, bool> PumpSetValues { get; set; } = new Dictionary<string, bool>();
        public Dictionary<string, bool> F2HFClnOrHFCl2Values { get; set; } = new Dictionary<string, bool>();

        private Dictionary<string, string> ChangedDictMFC(Dictionary<string, double> oldDict)
        {
            Dictionary<string, string> rtnKeyValue = new Dictionary<string, string>();
            foreach (var item in oldDict.Keys)
            {
                rtnKeyValue.Add(item, oldDict[item].ToString());
            }
            return rtnKeyValue;
        }

        public void PatternCmd()
        {
            string toolType = (string)QueryDataClient.Instance.Service.GetConfig("System.SetUp.ToolType");
            if (!string.IsNullOrEmpty(toolType) && toolType.Equals(ConstantsCommon.ELK))
            {
                FurnaceUI.Views.Maintenances.Maintenances.ELK.GasPanelViewModel gasPanelTwoView = new Maintenances.Maintenances.ELK.GasPanelViewModel();
                gasPanelTwoView.MFCDataList = MFCDataList;
                var rtn = (wm as WindowManager)?.ShowDialogWithTitle(gasPanelTwoView, null, "Manual Gas View");
                if ((bool)rtn)
                {
                    DictValve = gasPanelTwoView.DictChangedValve;
                    DictMFC = ChangedDictMFC(gasPanelTwoView.DictChangedMFC);
                    DictMFCRamp = ChangedDictMFC(gasPanelTwoView.DictChangedMFCRamp);
                    foreach (var item in DictMFC)
                    {
                        var tempMFC = MFCDataList.FirstOrDefault(x => x.Name == item.Key);
                        if (tempMFC != null)
                        {
                            tempMFC.IsSetChanged = false;
                            tempMFC.Value = item.Value;
                        }
                    }
                    foreach (var item in DictMFCRamp)
                    {
                        var tempMFC = MFCDataList.FirstOrDefault(x => x.Name == item.Key);
                        if (tempMFC != null)
                        {
                            tempMFC.IsRampngChanged = false;
                            tempMFC.Rampng = item.Value;
                        }
                    }

                    if (DictMFC.Count == 0 && DictMFCRamp.Count == 0)
                    {
                        for (int i = 0; i < MFCDataList.Count; i++)
                        {
                            double setLastPoint = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{MFCDataList[i].DisplayName}.SetLastPoint");
                            double setLastRamping = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{MFCDataList[i].DisplayName}.SetLastRamping");
                            MFCDataList[i].Value = setLastPoint.ToString("f3");
                            MFCDataList[i].Rampng = setLastRamping.ToString("f3");
                            MFCDataList[i].IsSetChanged = true;
                            MFCDataList[i].IsRampngChanged = true;
                        };
                    }
                    if (gasPanelTwoView.DictChangedPumpValve.Count > 0)
                    {
                        PumpSetValues.Clear();
                        if (gasPanelTwoView.AGVPumpData != null && gasPanelTwoView.AGVPumpData.DefaultValue != gasPanelTwoView.AGVPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AGVPumpData.UniqueName, gasPanelTwoView.AGVPumpData.Feedback);
                            // InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.AGVPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.AGVPumpData.Feedback);
                        }
                        if (gasPanelTwoView.AGV2PumpData != null && gasPanelTwoView.AGV2PumpData.DefaultValue != gasPanelTwoView.AGV2PumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AGV2PumpData.UniqueName, gasPanelTwoView.AGV2PumpData.Feedback);
                        }
                        if (gasPanelTwoView.AUCPumpData != null && gasPanelTwoView.AUCPumpData.DefaultValue != gasPanelTwoView.AUCPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AUCPumpData.UniqueName, gasPanelTwoView.AUCPumpData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.AUCPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.AUCPumpData.Feedback);
                        }
                        if (gasPanelTwoView.BothPump1Data != null && gasPanelTwoView.BothPump1Data.DefaultValue != gasPanelTwoView.BothPump1Data.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.BothPump1Data.UniqueName, gasPanelTwoView.BothPump1Data.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.BothPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.BothPumpData.Feedback);
                        }
                        if (gasPanelTwoView.BothPump2Data != null && gasPanelTwoView.BothPump2Data.DefaultValue != gasPanelTwoView.BothPump2Data.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.BothPump2Data.UniqueName, gasPanelTwoView.BothPump2Data.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.BothPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.BothPumpData.Feedback);
                        }
                        if (gasPanelTwoView.ValveBWRData != null && gasPanelTwoView.ValveBWRData.DefaultValue != gasPanelTwoView.ValveBWRData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.ValveBWRData.UniqueName, gasPanelTwoView.ValveBWRData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.ValveBWRData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.ValveBWRData.Feedback);
                        }
                        if (gasPanelTwoView.ValveDPRData != null && gasPanelTwoView.ValveDPRData.DefaultValue != gasPanelTwoView.ValveDPRData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.ValveDPRData.UniqueName, gasPanelTwoView.ValveDPRData.Feedback);
                            // InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.ValveDPRData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.ValveDPRData.Feedback);
                        }

                        if (gasPanelTwoView.HREFData != null && gasPanelTwoView.HREFData.DefaultValue != gasPanelTwoView.HREFData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.HREFData.UniqueName, gasPanelTwoView.HREFData.Feedback);
                        }

                        if (gasPanelTwoView.CREF2Data != null && gasPanelTwoView.CREF2Data.DefaultValue != gasPanelTwoView.CREF2Data.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.CREF2Data.UniqueName, gasPanelTwoView.CREF2Data.Feedback);

                        }
                        if (gasPanelTwoView.HZEROData != null && gasPanelTwoView.HZEROData.DefaultValue != gasPanelTwoView.HZEROData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.HZEROData.UniqueName, gasPanelTwoView.HZEROData.Feedback);
                        }

                        if (gasPanelTwoView.HMNTData != null && gasPanelTwoView.HMNTData.DefaultValue != gasPanelTwoView.HMNTData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.HMNTData.UniqueName, gasPanelTwoView.HMNTData.Feedback);
                        }

                        if (gasPanelTwoView.CMNTData != null && gasPanelTwoView.CMNTData.DefaultValue != gasPanelTwoView.CMNTData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.CMNTData.UniqueName, gasPanelTwoView.CMNTData.Feedback);
                        }

                        if (gasPanelTwoView.CZEROData != null && gasPanelTwoView.CZEROData.DefaultValue != gasPanelTwoView.CZEROData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.CZEROData.UniqueName, gasPanelTwoView.CZEROData.Feedback);
                        }

                        F2HFClnOrHFCl2Values.Clear();
                        if (gasPanelTwoView.IsDEPOOn != gasPanelTwoView.IsOldDEPOOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetDEPOEnable", gasPanelTwoView.IsDEPOOn);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                        }
                        if (gasPanelTwoView.IsF2ClnOn != gasPanelTwoView.IsOldF2ClnOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                        }
                        if (gasPanelTwoView.IsHFClnOn != gasPanelTwoView.IsOldHFClnOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHFClnEnable", gasPanelTwoView.IsHFClnOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHFClnEnable", gasPanelTwoView.IsHFClnOn);
                        }
                        if (gasPanelTwoView.IsHTR1Enable != gasPanelTwoView.IsOldHTR1Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR1Enable", gasPanelTwoView.IsHTR1Enable);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR1Enable", gasPanelTwoView.IsHTR1Enable);
                        }
                        if (gasPanelTwoView.IsHTR2Enable != gasPanelTwoView.IsOldHTR2Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                        if (gasPanelTwoView.IsHTR3Enable != gasPanelTwoView.IsOldHTR3Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR3Enable", gasPanelTwoView.IsHTR3Enable);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                        if (gasPanelTwoView.IsCEXHOn != gasPanelTwoView.IsOldCEXHOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetCEXHEnable", gasPanelTwoView.IsCEXHOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                        if (gasPanelTwoView.IsCREFOn != gasPanelTwoView.IsOldCREFOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetCREFEnable", gasPanelTwoView.IsCREFOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                        if (gasPanelTwoView.IsSIREFOn != gasPanelTwoView.IsOldSIREFOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetSIREFEnable", gasPanelTwoView.IsSIREFOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                    }
                }
            }
            else if (!string.IsNullOrEmpty(toolType) && toolType.Equals(ConstantsCommon.SIBCN))
            {
                FurnaceUI.Views.Maintenances.Maintenances.SiBCN.GasPanelViewModel gasPanelTwoView = new Maintenances.Maintenances.SiBCN.GasPanelViewModel();
                gasPanelTwoView.MFCDataList = MFCDataList;
                var rtn = (wm as WindowManager)?.ShowDialogWithTitle(gasPanelTwoView, null, " Gas Panel");
                if ((bool)rtn)
                {
                    DictValve = gasPanelTwoView.DictChangedValve;
                    DictMFC = ChangedDictMFC(gasPanelTwoView.DictChangedMFC);
                    foreach (var item in DictMFC)
                    {
                        var tempMFC = MFCDataList.FirstOrDefault(x => x.Name == item.Key);
                        if (tempMFC != null)
                        {
                            tempMFC.IsSetChanged = false;
                            tempMFC.Value = item.Value;
                        }
                    }

                    if (DictMFC.Count == 0)
                    {
                        for (int i = 0; i < MFCDataList.Count; i++)
                        {

                            double setLastPoint = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{MFCDataList[i].DisplayName}.SetLastPoint");
                            double setLastRamping = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{MFCDataList[i].DisplayName}.SetLastRamping");
                            MFCDataList[i].Value = setLastPoint.ToString("f3");
                            MFCDataList[i].Rampng = setLastRamping.ToString("f3");
                            MFCDataList[i].IsSetChanged = true;
                        };
                    }
                    if (gasPanelTwoView.DictChangedPumpValve.Count > 0)
                    {
                        PumpSetValues.Clear();
                        if (gasPanelTwoView.AGVPumpData != null && gasPanelTwoView.AGVPumpData.DefaultValue != gasPanelTwoView.AGVPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AGVPumpData.UniqueName, gasPanelTwoView.AGVPumpData.Feedback);
                            // InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.AGVPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.AGVPumpData.Feedback);
                        }
                        if (gasPanelTwoView.AUCPumpData != null && gasPanelTwoView.AUCPumpData.DefaultValue != gasPanelTwoView.AUCPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AUCPumpData.UniqueName, gasPanelTwoView.AUCPumpData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.AUCPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.AUCPumpData.Feedback);
                        }
                        if (gasPanelTwoView.BothPumpData != null && gasPanelTwoView.BothPumpData.DefaultValue != gasPanelTwoView.BothPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.BothPumpData.UniqueName, gasPanelTwoView.BothPumpData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.BothPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.BothPumpData.Feedback);
                        }
                        if (gasPanelTwoView.ValveBWRData != null && gasPanelTwoView.ValveBWRData.DefaultValue != gasPanelTwoView.ValveBWRData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.ValveBWRData.UniqueName, gasPanelTwoView.ValveBWRData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.ValveBWRData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.ValveBWRData.Feedback);
                        }
                        if (gasPanelTwoView.ValveDPRData != null && gasPanelTwoView.ValveDPRData.DefaultValue != gasPanelTwoView.ValveDPRData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.ValveDPRData.UniqueName, gasPanelTwoView.ValveDPRData.Feedback);
                            // InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.ValveDPRData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.ValveDPRData.Feedback);
                        }
                        F2HFClnOrHFCl2Values.Clear();
                        if (gasPanelTwoView.IsDEPOOn != gasPanelTwoView.IsOldDEPOOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetDEPOEnable", gasPanelTwoView.IsDEPOOn);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                        }
                        if (gasPanelTwoView.IsF2ClnOn != gasPanelTwoView.IsOldF2ClnOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                        }
                        if (gasPanelTwoView.IsHFClnOn != gasPanelTwoView.IsOldHFClnOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHFClnEnable", gasPanelTwoView.IsHFClnOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHFClnEnable", gasPanelTwoView.IsHFClnOn);
                        }
                        if (gasPanelTwoView.IsHTR1Enable != gasPanelTwoView.IsOldHTR1Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR1Enable", gasPanelTwoView.IsHTR1Enable);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR1Enable", gasPanelTwoView.IsHTR1Enable);
                        }
                        if (gasPanelTwoView.IsHTR2Enable != gasPanelTwoView.IsOldHTR2Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                        if (gasPanelTwoView.IsHTR3Enable != gasPanelTwoView.IsOldHTR3Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR3Enable", gasPanelTwoView.IsHTR3Enable);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                        if (gasPanelTwoView.IsCEXHOn != gasPanelTwoView.IsOldCEXHOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetCEXHEnable", gasPanelTwoView.IsCEXHOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                    }
                }
            }
            else if (!string.IsNullOrEmpty(toolType) && toolType.Equals(ConstantsCommon.TiN))
            {
                FurnaceUI.Views.Maintenances.Maintenances.TiN.GasPanelViewModel gasPanelTwoView = new Maintenances.Maintenances.TiN.GasPanelViewModel();
                gasPanelTwoView.MFCDataList = MFCDataList;
                var rtn = (wm as WindowManager)?.ShowDialogWithTitle(gasPanelTwoView, null, " Gas Panel");
                if ((bool)rtn)
                {
                    DictValve = gasPanelTwoView.DictChangedValve;
                    DictMFC = ChangedDictMFC(gasPanelTwoView.DictChangedMFC);
                    foreach (var item in DictMFC)
                    {
                        var tempMFC = MFCDataList.FirstOrDefault(x => x.Name == item.Key);
                        if (tempMFC != null)
                        {
                            tempMFC.IsSetChanged = false;
                            tempMFC.Value = item.Value;
                        }
                    }

                    if (DictMFC.Count == 0)
                    {
                        for (int i = 0; i < MFCDataList.Count; i++)
                        {

                            double setLastPoint = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{MFCDataList[i].DisplayName}.SetLastPoint");
                            double setLastRamping = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{MFCDataList[i].DisplayName}.SetLastRamping");
                            MFCDataList[i].Value = setLastPoint.ToString("f3");
                            MFCDataList[i].Rampng = setLastRamping.ToString("f3");
                            MFCDataList[i].IsSetChanged = true;
                        };
                    }
                    if (gasPanelTwoView.DictChangedPumpValve.Count > 0)
                    {
                        PumpSetValues.Clear();
                        if (gasPanelTwoView.AGVPumpData != null && gasPanelTwoView.AGVPumpData.DefaultValue != gasPanelTwoView.AGVPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AGVPumpData.UniqueName, gasPanelTwoView.AGVPumpData.Feedback);
                            // InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.AGVPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.AGVPumpData.Feedback);
                        }
                        if (gasPanelTwoView.AUCPumpData != null && gasPanelTwoView.AUCPumpData.DefaultValue != gasPanelTwoView.AUCPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AUCPumpData.UniqueName, gasPanelTwoView.AUCPumpData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.AUCPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.AUCPumpData.Feedback);
                        }
                        if (gasPanelTwoView.BothPumpData != null && gasPanelTwoView.BothPumpData.DefaultValue != gasPanelTwoView.BothPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.BothPumpData.UniqueName, gasPanelTwoView.BothPumpData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.BothPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.BothPumpData.Feedback);
                        }
                        if (gasPanelTwoView.ValveBWRData != null && gasPanelTwoView.ValveBWRData.DefaultValue != gasPanelTwoView.ValveBWRData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.ValveBWRData.UniqueName, gasPanelTwoView.ValveBWRData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.ValveBWRData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.ValveBWRData.Feedback);
                        }
                        if (gasPanelTwoView.ValveDPRData != null && gasPanelTwoView.ValveDPRData.DefaultValue != gasPanelTwoView.ValveDPRData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.ValveDPRData.UniqueName, gasPanelTwoView.ValveDPRData.Feedback);
                            // InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.ValveDPRData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.ValveDPRData.Feedback);
                        }
                        F2HFClnOrHFCl2Values.Clear();
                        if (gasPanelTwoView.IsDEPOOn != gasPanelTwoView.IsOldDEPOOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetDEPOEnable", gasPanelTwoView.IsDEPOOn);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                        }
                        if (gasPanelTwoView.IsF2ClnOn != gasPanelTwoView.IsOldF2ClnOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                        }
                        if (gasPanelTwoView.IsHFClnOn != gasPanelTwoView.IsOldHFClnOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHFClnEnable", gasPanelTwoView.IsHFClnOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHFClnEnable", gasPanelTwoView.IsHFClnOn);
                        }
                        if (gasPanelTwoView.IsHTR1Enable != gasPanelTwoView.IsOldHTR1Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR1Enable", gasPanelTwoView.IsHTR1Enable);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR1Enable", gasPanelTwoView.IsHTR1Enable);
                        }
                        if (gasPanelTwoView.IsHTR2Enable != gasPanelTwoView.IsOldHTR2Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                        if (gasPanelTwoView.IsHTR3Enable != gasPanelTwoView.IsOldHTR3Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR3Enable", gasPanelTwoView.IsHTR3Enable);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                        if (gasPanelTwoView.IsCEXHOn != gasPanelTwoView.IsOldCEXHOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetCEXHEnable", gasPanelTwoView.IsCEXHOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                    }
                }
            }
            else
            {

                FurnaceUI.Views.Maintenances.GasPanelTwoViewModel gasPanelTwoView = new FurnaceUI.Views.Maintenances.GasPanelTwoViewModel();
                gasPanelTwoView.MFCDataList = MFCDataList;
                var rtn = (wm as WindowManager)?.ShowDialogWithTitle(gasPanelTwoView, null, " Gas Panel");
                if ((bool)rtn)
                {
                    DictValve = gasPanelTwoView.DictChangedValve;
                    DictMFC = ChangedDictMFC(gasPanelTwoView.DictChangedMFC);
                    foreach (var item in DictMFC)
                    {
                        var tempMFC = MFCDataList.FirstOrDefault(x => x.Name == item.Key);
                        if (tempMFC != null)
                        {
                            tempMFC.IsSetChanged = false;
                            tempMFC.Value = item.Value;
                        }
                    }
                    if (DictMFC.Count == 0)
                    {
                        for (int i = 0; i < MFCDataList.Count; i++)
                        {

                            double setLastPoint = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{MFCDataList[i].DisplayName}.SetLastPoint");
                            double setLastRamping = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{MFCDataList[i].DisplayName}.SetLastRamping");
                            MFCDataList[i].Value = setLastPoint.ToString("f3");
                            MFCDataList[i].Rampng = setLastRamping.ToString("f3");
                            MFCDataList[i].IsSetChanged = true;
                        };
                    }
                    if (gasPanelTwoView.DictChangedPumpValve.Count > 0)
                    {
                        PumpSetValues.Clear();
                        if (gasPanelTwoView.AGVPumpData != null && gasPanelTwoView.AGVPumpData.DefaultValue != gasPanelTwoView.AGVPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AGVPumpData.UniqueName, gasPanelTwoView.AGVPumpData.Feedback);
                            // InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.AGVPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.AGVPumpData.Feedback);
                        }
                        if (gasPanelTwoView.AUCPumpData != null && gasPanelTwoView.AUCPumpData.DefaultValue != gasPanelTwoView.AUCPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.AUCPumpData.UniqueName, gasPanelTwoView.AUCPumpData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.AUCPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.AUCPumpData.Feedback);
                        }
                        if (gasPanelTwoView.BothPumpData != null && gasPanelTwoView.BothPumpData.DefaultValue != gasPanelTwoView.BothPumpData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.BothPumpData.UniqueName, gasPanelTwoView.BothPumpData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.BothPumpData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.BothPumpData.Feedback);
                        }
                        if (gasPanelTwoView.ValveBWRData != null && gasPanelTwoView.ValveBWRData.DefaultValue != gasPanelTwoView.ValveBWRData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.ValveBWRData.UniqueName, gasPanelTwoView.ValveBWRData.Feedback);
                            //  InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.ValveBWRData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.ValveBWRData.Feedback);
                        }
                        if (gasPanelTwoView.ValveDPRData != null && gasPanelTwoView.ValveDPRData.DefaultValue != gasPanelTwoView.ValveDPRData.Feedback)
                        {
                            PumpSetValues.Add(gasPanelTwoView.ValveDPRData.UniqueName, gasPanelTwoView.ValveDPRData.Feedback);
                            // InvokeClient.Instance.Service.DoOperation($"{gasPanelTwoView.ValveDPRData.UniqueName}.{AITValveOperation.GVTurnValve}", gasPanelTwoView.ValveDPRData.Feedback);
                        }
                        F2HFClnOrHFCl2Values.Clear();
                        if (gasPanelTwoView.IsF2ClnOn != gasPanelTwoView.IsOldF2ClnOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", gasPanelTwoView.IsF2ClnOn);
                        }
                        if (gasPanelTwoView.IsHFClnOn != gasPanelTwoView.IsOldHFClnOn)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHFClnEnable", gasPanelTwoView.IsHFClnOn);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHFClnEnable", gasPanelTwoView.IsHFClnOn);
                        }
                        if (gasPanelTwoView.IsHTR1Enable != gasPanelTwoView.IsOldHTR1Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR1Enable", gasPanelTwoView.IsHTR1Enable);
                            // InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR1Enable", gasPanelTwoView.IsHTR1Enable);
                        }
                        if (gasPanelTwoView.IsHTR2Enable != gasPanelTwoView.IsOldHTR2Enable)
                        {
                            F2HFClnOrHFCl2Values.Add("PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                            //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", gasPanelTwoView.IsHTR2Enable);
                        }
                    }
                }
            }


        }

        public void SwitchPage(string page)
        {
            switch (page)
            {

                case "Pressure":
                    {
                        ClientApp.Instance.SwitchPage("maintenance", "GasPanel", null);
                    }
                    break;

            }
        }


        public void RampSetClick(object sender)
        {
            string strSetRamp = ShowNumberKeyboard(sender as Button, "", 1);
            foreach (var item in TempList)
            {
                item.Rampng = strSetRamp;
                item.IsRampngChanged = false;
            }
        }

        private string ShowNumberKeyboard(Control control, string defaultValue, int keepDecimals = -1)
        {
            NumberKeyboard numberKeyboard = new NumberKeyboard("", defaultValue);
            numberKeyboard.KeepDecimals = keepDecimals;
            var point = control.PointFromScreen(new Point(0, 0));
            double wx = SystemParameters.WorkArea.Width;
            double hy = SystemParameters.WorkArea.Height;
            if (-point.Y + control.ActualHeight + 5 + numberKeyboard.Height < hy)
            {
                numberKeyboard.Top = -point.Y + control.ActualHeight + 5;
            }
            else
            {
                numberKeyboard.Top = -point.Y - numberKeyboard.Height - 5;
            }
            if (-point.X + numberKeyboard.Width < wx)
            {
                numberKeyboard.Left = -point.X;
            }
            else
            {
                numberKeyboard.Left = -point.X - (numberKeyboard.Width - control.ActualWidth);
            }
            if ((bool)numberKeyboard.ShowDialog())
                return numberKeyboard.ValueString;
            else
                return "Cancel";
        }
        private string SplitTemperatureControlMode(string str)
        {
            if (string.IsNullOrEmpty(str))
            {
                return str;
            }
            if (str.Contains("Profile("))
            {
                return str.Replace("Profile(", "").Replace(")", "").Replace(",", ":");
            }
            return str;
        }
        public void TempTextClick(string type, object sender)
        {
            switch (type)
            {
                case "Mode":
                    RecipeTempModeViewModel recipeTempModeViewModel = new RecipeTempModeViewModel();
                    recipeTempModeViewModel.SelectBtnName = SelectBtnName;
                    recipeTempModeViewModel.IsManualSet = true;
                    recipeTempModeViewModel.SelectProfileTable = SplitTemperatureControlMode(TemperatureControlMode);
                    var rtn = (wm as WindowManager)?.ShowDialogWithTitle(recipeTempModeViewModel, null, "Temp Mode");
                    if ((bool)rtn)
                    {
                        SelectBtnName = recipeTempModeViewModel.SelectBtnName;
                        if (null != recipeTempModeViewModel && !string.IsNullOrEmpty(recipeTempModeViewModel.ResultString) && recipeTempModeViewModel.ResultString.Contains("Profile"))
                        {
                            SelectBtnName = "Profile";
                        }
                        if (!string.IsNullOrEmpty(recipeTempModeViewModel.ResultString) && recipeTempModeViewModel.ResultString.Contains("Profile(,"))
                        {
                            recipeTempModeViewModel.ResultString = recipeTempModeViewModel.ResultString.Replace("Profile(,", "Profile(");
                        }
                        TemperatureControlMode = recipeTempModeViewModel.ResultString;
                    }
                    break;
                case "Correct":
                    TempCorrectionEditViewModel tempCorrectionEditViewModel = new TempCorrectionEditViewModel();
                    tempCorrectionEditViewModel.ResultString = TemperatureCorrect;
                    tempCorrectionEditViewModel.IsManualSet = true;
                    //tempCorrectionEditViewModel.SelectedRecipeStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    tempCorrectionEditViewModel.IsEnabledControl = false;
                    tempCorrectionEditViewModel.AutoSelectVisibility = Visibility.Visible;
                    //  tempOffsetTableViewModel.SelectedRecipeStep = SelectedRecipeStep;
                    rtn = (wm as WindowManager)?.ShowDialogWithTitle(tempCorrectionEditViewModel, null, "Temp Correct Table");
                    if ((bool)rtn)
                    {
                        TemperatureCorrect = tempCorrectionEditViewModel.ResultString;
                    }
                    break;
                case "PID":
                    TempOffsetTableViewModel tempOffsetTableViewModel1 = new TempOffsetTableViewModel();
                    tempOffsetTableViewModel1.CboAutoSelectChecked = false;
                    tempOffsetTableViewModel1.IsEnabledControl = false;
                    tempOffsetTableViewModel1.IsManualSet = true;
                    tempOffsetTableViewModel1.TempOffsetTableSelected = TemperaturePID;
                    rtn = (wm as WindowManager)?.ShowDialogWithTitle(tempOffsetTableViewModel1, null, "Temp PID Table");
                    if ((bool)rtn)
                    {
                        TemperaturePID = tempOffsetTableViewModel1.TempOffsetTableSelected;
                    }
                    break;
                default:
                    break;
            }

        }

        private ObservableCollection<AUXData> _aUXDatas;

        public void StepEdit(object cmdName, object value)
        {
            switch ((string)cmdName)
            {
                case "GASSetting":
                    RecipeMFCSettingViewModel recipeMFCSettingViewModel = new RecipeMFCSettingViewModel();
                    //InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorRecipeOK", "");
                    //var tempMFCSets = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().MFCSets;
                    //if (tempMFCSets != null && tempMFCSets.Count > 0)
                    //{
                    //    foreach (var item in tempMFCSets.Keys)
                    //    {
                    //        if (recipeMFCSettingViewModel.MFCSets.ContainsKey(item))
                    //        {
                    //            recipeMFCSettingViewModel.MFCSets[item] = tempMFCSets[item];
                    //        }
                    //        else
                    //        {
                    //            //recipeGASSettingViewModel.MFCSets.Add(item, tempMFCSets[item]);
                    //            recipeMFCSettingViewModel.MFCSets.Add(item, new MFCValue() { AlarmValue = tempMFCSets[item].MinValue, IsNotifying = tempMFCSets[item].IsNotifying, MaxValue = tempMFCSets[item].MaxValue, MinValue = tempMFCSets[item].MinValue, IsCheck = tempMFCSets[item].IsCheck, Name = tempMFCSets[item].Name, Rampng = tempMFCSets[item].Rampng, Value = tempMFCSets[item].Value });
                    //        }
                    //    }
                    //}
                    ////recipeGASSettingViewModel.MFMSets = new MFMValue() { AlarmValue = tempMFMSets.AlarmValue, IsNotifying = tempMFMSets.IsNotifying, Name = tempMFMSets.Name, Value = tempMFMSets.Value };
                    //recipeMFCSettingViewModel.RecipeType = RecipeType;
                    //recipeMFCSettingViewModel.RecipeTemplate = RecipeTemplate;
                    //if (!(bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeMFCSettingViewModel, null, "MFC Detail"))
                    //{
                    //    //InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorPROCManualOK", "");
                    //    return;
                    //}
                    ////InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorPROCManualOK", "");
                    //if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().MFCSets != null)
                    //{
                    //    if (recipeMFCSettingViewModel.MFCSets != null && recipeMFCSettingViewModel.MFCSets.Count > 0)
                    //    {
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().MFCSets = recipeMFCSettingViewModel.MFCSets;
                    //    }
                    //}
                    break;
                case "PressureSetting":

                    RecipePressureSettingViewModel recipePressureSettingViewModel = new RecipePressureSettingViewModel();
                    //var tempStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    //recipePressureSettingViewModel.PressureSonsorValue = tempStep.PressureSonserValue;
                    //recipePressureSettingViewModel.PressureValveAngleValue = tempStep.PressureValveAngle;
                    //recipePressureSettingViewModel.PressureSettingVG = tempStep.PressureSettingVG;
                    //if (!string.IsNullOrEmpty(tempStep.PressureAlarmTableNo))
                    //{
                    //    if (tempStep.PressureAlarmTableNo.ToLower() == "none")
                    //        recipePressureSettingViewModel.PressureAlarmWatchTable = "None";
                    //    else
                    //        recipePressureSettingViewModel.PressureAlarmWatchTable = tempStep.PressureAlarmTableNo;
                    //}
                    //if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipePressureSettingViewModel, null, "Recipe Pressure Setting"))
                    //{
                    //    if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault() != null)
                    //    {
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureSonserValue = recipePressureSettingViewModel.PressureSonsorValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureValveAngle = recipePressureSettingViewModel.PressureValveAngleValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureAlarmTableNo = recipePressureSettingViewModel.PressureAlarmWatchTable;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureSettingVG = recipePressureSettingViewModel.PressureSettingVG;
                    //        SelectedRecipeStep.PressureSonserValue = $"{recipePressureSettingViewModel.PressureSonsorValue}";
                    //    }
                    //}
                    break;
                case "RFSetting":
                    //RecipeRFPressureSettingViewModel recipeRFPressureSettingViewModel = new RecipeRFPressureSettingViewModel();
                    //var tempRecipeStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    //recipeRFPressureSettingViewModel.RFSwitch = tempRecipeStep.RFSwitch;
                    //recipeRFPressureSettingViewModel.RFSetPointValue = tempRecipeStep.RFSetpoint;
                    //recipeRFPressureSettingViewModel.C1SetPointValue = tempRecipeStep.C1Setpoint;
                    //recipeRFPressureSettingViewModel.C2SetPointValue = tempRecipeStep.C2Setpoint;
                    //recipeRFPressureSettingViewModel.ForwardPowerAlarmWatchSetPointValue = tempRecipeStep.ForwardPowerAlarmWatchTable;
                    //recipeRFPressureSettingViewModel.PrAlarmWatchSetPointValue = tempRecipeStep.PrAlarmWatchTable;
                    //recipeRFPressureSettingViewModel.PIAlarmWatchSetPointValue = tempRecipeStep.PIAlarmWatchTable;
                    //recipeRFPressureSettingViewModel.C1AlarmWatchSetPointValue = tempRecipeStep.C1AlarmWatchTable;
                    //recipeRFPressureSettingViewModel.C2AlarmWatchSetPointValue = tempRecipeStep.C2AlarmWatchTable;
                    //recipeRFPressureSettingViewModel.VppAlarmWatchSetPointValue = tempRecipeStep.VppAlarmWatchTable;
                    //recipeRFPressureSettingViewModel.VdcAlarmWatchSetPointValue = tempRecipeStep.VdcAlarmWatchTable;
                    //if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeRFPressureSettingViewModel, null, "Recipe RF Setting"))
                    //{
                    //    if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault() != null)
                    //    {
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RFSwitch = recipeRFPressureSettingViewModel.RFSwitch;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RFSetpoint = recipeRFPressureSettingViewModel.RFSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().C1Setpoint = recipeRFPressureSettingViewModel.C1SetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().C2Setpoint = recipeRFPressureSettingViewModel.C2SetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ForwardPowerAlarmWatchTable = recipeRFPressureSettingViewModel.ForwardPowerAlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PrAlarmWatchTable = recipeRFPressureSettingViewModel.PrAlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PIAlarmWatchTable = recipeRFPressureSettingViewModel.PIAlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().C1AlarmWatchTable = recipeRFPressureSettingViewModel.C1AlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().C2AlarmWatchTable = recipeRFPressureSettingViewModel.C2AlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().VppAlarmWatchTable = recipeRFPressureSettingViewModel.VppAlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().VdcAlarmWatchTable = recipeRFPressureSettingViewModel.VdcAlarmWatchSetPointValue;
                    //        // SelectedRecipeStep.RFSetting = $"{recipeRFPressureSettingViewModel.RFSetPointValue}";
                    //    }
                    //}
                    break;
                case "Loader":
                    RecipeLoaderCommandViewModel recipeLoaderCommandViewModel = new RecipeLoaderCommandViewModel();
                    recipeLoaderCommandViewModel.SetRecipeProcessEditViewEnable = false;
                    if ((bool)(wm as WindowManager)?.ShowDialogWithTitle(recipeLoaderCommandViewModel, null, "Loader Command"))
                    {
                        ClearLoaderSetValue();
                        LoaderCommand = recipeLoaderCommandViewModel.ReturnString;
                        SetShowLoaderValuePanel(recipeLoaderCommandViewModel.ReturnString);
                    }
                    break;
                case "Pressure":
                    ManualPressCommandViewModel recipePressCommandViewModel = new ManualPressCommandViewModel();
                    recipePressCommandViewModel.SetRecipeProcessEditViewEnable = false;
                    recipePressCommandViewModel.SelectedCmd = PressCommand;
                    if ((bool)(wm as WindowManager)?.ShowDialogWithTitle(recipePressCommandViewModel, null, "Press Command"))
                    {
                        DefaultUnit = recipePressCommandViewModel.DefaultUnit;
                        string returnString = recipePressCommandViewModel.ReturnString;
                        PressCommand = returnString;
                        SetShowPressPanel(returnString);
                    }
                    break;
                case "Pattern":
                    RecipeGasPanelSettingViewModel recipeGasPanelSettingViewModel = new RecipeGasPanelSettingViewModel();
                    //recipeGasPanelSettingViewModel.CurrentRecipe = CurrentRecipe;
                    //recipeGasPanelSettingViewModel.SelectedStepName = $"{SelectedRecipeStep.StepNo}:{SelectedRecipeStep.Name}";
                    //recipeGasPanelSettingViewModel.ChangedStepEvent += RecipeGasPanelSettingViewModel_ChangedStepEvent;
                    //recipeGasPanelSettingViewModel.SelectedStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    if ((bool)(wm as WindowManager)?.ShowDialogWithTitle(recipeGasPanelSettingViewModel, null, "Valve"))
                    {

                    }
                    break;
                case "BoatElevatorSetting":
                    BoatElevatorSettingViewModel boatElevatorSettingViewModel = new BoatElevatorSettingViewModel();
                    //boatElevatorSettingViewModel.SelectedRecipeStep = SelectedRecipeStep;
                    //if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(boatElevatorSettingViewModel, null, "BoatElevator Setting"))
                    //{
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ZAxisPosition = boatElevatorSettingViewModel.SelectedRecipeStep.ZAxisPosition;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ZAxisSpeed = boatElevatorSettingViewModel.SelectedRecipeStep.ZAxisSpeed;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RotatePosition = boatElevatorSettingViewModel.SelectedRecipeStep.RotatePosition;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RotateSpeed = boatElevatorSettingViewModel.SelectedRecipeStep.RotateSpeed;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RotateInterval = boatElevatorSettingViewModel.SelectedRecipeStep.RotateInterval;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RotateDirection = boatElevatorSettingViewModel.SelectedRecipeStep.RotateDirection;
                    //}
                    break;
                case "AUX":
                    
                    RecipeAUXSetViewModel recipeAUXSetViewModel = new RecipeAUXSetViewModel();
                    if (_aUXDatas != null && _aUXDatas.Count > 0)
                    {
                        recipeAUXSetViewModel.AUXDataList.Clear();
                        _aUXDatas.ToList().ForEach(x => recipeAUXSetViewModel.AUXDataList.Add(x));
                    }
                    else
                    {
                        int i = 1;
                        recipeAUXSetViewModel.AUXDataList.Clear();
                        foreach (var item in AUXDetailDatas)
                        {
                            var tempAux = new AUXData();
                            tempAux.No = i;
                            tempAux.ControlName = i.ToString();
                            tempAux.DisplayName = item.DisplayName;
                            tempAux.SetValue = new DoubleParam() { Name = "SetValue", Value = item.SetPoint.ToString() };
                            tempAux.IsCheck = new BoolParam() { Name = "IsCheck", Value = false };
                            tempAux.MaxValue = new DoubleParam() { Name = "MaxValue", Value = item.WarningHighLimit.ToString() };
                            tempAux.MinValue = new DoubleParam() { Name = "MinValue", Value = item.WarningLowLimit.ToString() };
                            tempAux.SetUnit = new StringParam() { Name = "SetUnit", Value = item.Unit };
                            recipeAUXSetViewModel.AUXDataList.Add(tempAux);
                            i++;
                        }
                    }
                    if ((bool)(wm as WindowManager)?.ShowDialogWithTitle(recipeAUXSetViewModel, null, "AUX Set"))
                    {
                        _aUXDatas = recipeAUXSetViewModel.AUXDataList;

                    }
                    break;
                case "RecipeHeader":
                    RecipeHeaderViewModel recipeHeaderViewModel = new RecipeHeaderViewModel();
                    if ((bool)(wm as WindowManager)?.ShowDialogWithTitle(recipeHeaderViewModel, null, "Recipe Header"))
                    {
                    }
                    break;
                case "Combination":
                    //StringParam strCombination = CurrentRecipe.ConfigItems.FirstOrDefault(x => x.Name == "Combination") as StringParam;
                    //RecipeCombinationViewModel recipeCombinationViewModel = new RecipeCombinationViewModel();
                    //recipeCombinationViewModel.CombinationStr = strCombination.Value;
                    //if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeCombinationViewModel, null, "Combination"))
                    //{
                    //    strCombination.Value = recipeCombinationViewModel.Combination.ToString();
                    //}
                    break;
                case "VPDataList":
                    RecipeVPItemSelectViewModel recipeVPItemSelectViewModel = new RecipeVPItemSelectViewModel();
                    if ((bool)(wm as WindowManager)?.ShowDialogWithTitle(recipeVPItemSelectViewModel, null, "VP Item Select"))
                    {
                    }
                    break;
                case "SkipOrWait":
                    RecipeSkipWaitCommandViewModel recipeSkipWaitCommandViewModel = new RecipeSkipWaitCommandViewModel();
                    //recipeSkipWaitCommandViewModel.SkipWait = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().SkipWait;
                    //if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeSkipWaitCommandViewModel, null, "Skip or wait command"))
                    //{
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().SkipWait = recipeSkipWaitCommandViewModel.RtnString;
                    //    SelectedRecipeStep.SkipWait = recipeSkipWaitCommandViewModel.RtnString;
                    //}
                    break;
                default:
                    break;
            }

        }

        public void MFCTextChanged(string type, object sender, object item)
        {
            BrushConverter brushConverter = new BrushConverter();
            try
            {
                if (!string.IsNullOrEmpty(type) && item != null && sender != null)
                {
                    MFCGasData mFCData = (MFCGasData)item;
                    string value = ((TextBox)sender).Text;
                    string proStr = $"{mFCData.Name}Data";
                    Type type1 = typeof(ManualSetViewModel);
                    PropertyInfo property = type1.GetProperty(proStr);
                    if (property == null) return;
                    AITMfcData aITMfcData = (AITMfcData)property.GetValue(this);
                    double setValue = 0;
                    double.TryParse(value, out setValue);
                    var maxData = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{mFCData.Name}.N2Scale");
                    if (setValue > maxData && type == "Value")
                    {
                        DialogBox.ShowWarning($"{mFCData.Name} Out of the setting range {0}~{maxData}!");
                        ((TextBoxEx)sender).ChangedColor = ((TextBoxEx)sender).NormalColor;
                        ((TextBoxEx)sender).Text = $"0";
                        return;
                    }


                    switch (type)
                    {
                        case "Value":
                            mFCData.Value = value;

                            if (setValue != aITMfcData.SetPoint)
                            {
                                ((TextBoxEx)sender).ChangedColor = (Brush)brushConverter.ConvertFromString("Yellow");
                                mFCData.IsSetChanged = false;
                            }
                            else
                            {
                                // mFCData.IsSetChanged = true;
                            }
                            break;
                        case "Rampng":
                            mFCData.Rampng = value;

                            if (setValue != aITMfcData.Ramping)
                            {
                                mFCData.IsRampngChanged = false;
                            }
                            else
                            {
                                // mFCData.IsRampngChanged = true;
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
        }

        public void TempTextChanged(string type, object sender, object item)
        {
            try
            {
                if (!string.IsNullOrEmpty(type) && item != null && sender != null)
                {
                    TempManualSetData tempData = (TempManualSetData)item;
                    string value = ((TextBox)sender).Text;
                    string proStr = tempData.ControlName;
                    Type type1 = typeof(ManualSetViewModel);
                    PropertyInfo property = type1.GetProperty(proStr);
                    if (property == null) return;
                    AITHeaterData aITHeaterData = (AITHeaterData)property.GetValue(this);
                    double setValue = 0;
                    double.TryParse(value, out setValue);
                    switch (type)
                    {
                        case "Value":
                            tempData.Value = value;

                            if (setValue != aITHeaterData.SetPoint)
                            {
                                tempData.IsSetChanged = false;
                            }
                            else
                            {
                                // tempData.IsSetChanged = false;
                            }
                            break;
                        case "Ramp":
                            tempData.Rampng = value;

                            if (setValue != aITHeaterData.RampSetPoint)
                            {
                                tempData.IsRampngChanged = false;
                            }
                            else
                            {
                                // tempData.IsRampngChanged = false;
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }

        }

        private string oldPressStr = "";

        public void Exec()
        {
            if (!DialogBox.Confirm("Are you sure to execute?"))
                return;
            if (DictValve != null && DictValve.Count > 0)
            {
                InvokeClient.Instance.Service.DoOperation($"PM1.SetAll{AITValveOperation.GVTurnValve}", DictValve);
            }
            if (MFCDataList != null && MFCDataList.Count() > 0)
            {
                Dictionary<string, string> setChangedMFC = new Dictionary<string, string>();
                var changedList = MFCDataList.ToList().Where(x => !x.IsSetChanged);
                foreach (var item in changedList)
                {
                    setChangedMFC.Add(item.Name, item.Value);
                }
                InvokeClient.Instance.Service.DoOperation($"PM1.SetAllMfcValue", setChangedMFC);
                MFCDataList.ToList().ForEach(x =>
                {
                    if (!x.IsSetChanged)
                    {
                        //  InvokeClient.Instance.Service.DoOperation($"PM1.{x.DisplayName}.SetMfcValue", $"{x.Value};{x.Rampng};{x.AlarmValue}");
                        InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"PM1.MFC.{x.DisplayName}.SetLastPoint", x.Value);
                        x.IsSetChanged = true;
                    }
                    if (!x.IsRampngChanged)
                    {
                        InvokeClient.Instance.Service.DoOperation($"PM1.{x.DisplayName}.SetMfcValue", $"{x.Value};{x.Rampng};{x.AlarmValue}");
                        InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"PM1.MFC.{x.DisplayName}.SetLastRamping", x.Rampng);
                        x.IsRampngChanged = true;
                    }
                });
            }

            var pressStr = GetPressString();
            if (oldPressStr != pressStr || (DictValve != null && DictValve.ContainsKey("ValveAV71")))
            {
                if ((CheckIsChanged(pressStr) && pressStr != ";;;") || (DictValve != null && DictValve.ContainsKey("ValveAV71")))
                {
                    if (DictValve != null && DictValve.ContainsKey("ValveAV71"))
                        InvokeClient.Instance.Service.DoOperation($"PM1.APC.SetManualParameters", $"{pressStr};{DictValve["ValveAV71"]}");
                    else
                        InvokeClient.Instance.Service.DoOperation($"PM1.APC.SetManualParameters", $"{pressStr}");
                }
            }
            OldPressCommand = PressCommand;
            oldPressStr = pressStr;
            if (HeaterUData.CorrectTable != TemperatureCorrect || HeaterUData.PIDTable != TemperaturePID || HeaterUData.ControlModeSetpoint != TemperatureControlMode)
            {
                string[] tempPra = new string[] { TemperatureControlMode, TemperatureCorrect, TemperaturePID };
                InvokeClient.Instance.Service.DoOperation("PM1.Heater.SetParameters", string.Join(";", tempPra));
            }
            if (TempList != null && TempList.Count() > 0)
            {
                TempList.ToList().ForEach(x =>
                {
                    if (!x.IsRampngChanged || !x.IsSetChanged)
                    {
                        InvokeClient.Instance.Service.DoOperation($"System.{x.Name}.SetManualParameters", $"{x.Value};{x.Rampng}");
                        if (!x.IsSetChanged)
                        {
                            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"PM1.Heater.{x.Name}.SetLastPoint", x.Value);
                        }
                        if (!x.IsRampngChanged)
                        {
                            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"PM1.Heater.{x.Name}.SetLastRamping", x.Rampng);
                        }
                        x.IsSetChanged = true;
                        x.IsRampngChanged = true;
                    }
                });
            }
            if (!string.IsNullOrEmpty(LoaderCommand))
            {
                if (OldLoaderCommand != LoaderCommand)
                {
                    InvokeClient.Instance.Service.DoOperation("PM1.SetBoatManualMotion", GetSaveLoaderValue(LoaderCommand));
                }
                OldLoaderCommand = LoaderCommand;
            }
            if (PumpSetValues.Count > 0)
            {
                PumpSetValues.ToList().ForEach(x => InvokeClient.Instance.Service.DoOperation($"{x.Key}.{AITValveOperation.GVTurnValve}", x.Value));
            }
            if (F2HFClnOrHFCl2Values.Count > 0)
            {
                F2HFClnOrHFCl2Values.ToList().ForEach(x => InvokeClient.Instance.Service.DoOperation(x.Key, x.Value));
            }
        }

        private bool CheckIsChanged(string value)
        {
            string[] strList = value.Split(';');
            if (APCData.CommandSetPoint != strList[0])
            {
                return true;
            }
            if (APCData.PIDTable != strList[1])
            {
                return true;
            }

            float.TryParse(strList[2], out float set);
            if (APCData.SetPoint != set)
            {
                return true;
            }
            if (APCData.LowPressWaitSetPoint != strList[3])
            {
                return true;
            }
            return false;
        }

        public List<ConfigNode> GetMfcItem()
        {
            this.SystemName = "System";
            ConfigNodes = SystemConfigProvider.Instance.GetConfigTree(SystemName).SubNodes;
            var MfcItems = ConfigNodes.Where(x => x.Display == "Parameter").FirstOrDefault().SubNodes.Where(y => y.Name == "MFC").FirstOrDefault().SubNodes;
            return MfcItems;
        }

        public void RecipeCancel()
        {
            if (DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM, " You confirm that you want to unsave the recipe and exit the interface?") == DialogButton.No)
            {
                return;
            }
            else
            {
                UpdateGASSetting(true);
                UpdateHeaterSetting();
                ClearSetValue();
            }

            // ((Window)GetView()).Close();
        }

        public void PressPIDChick()
        {
            var windowManager = IoC.Get<IWindowManager>();

            var defaultAPCPID = SystemConfigProvider.Instance.GetValueByName("PM1.APCPID");
            if (string.IsNullOrEmpty(defaultAPCPID))
            {
                DialogBox.ShowDialog(DialogButton.Cancel, DialogType.INFO, "Please set the default file first");
                return;
            }
            int last = defaultAPCPID.LastIndexOf('\\');
            var pix = defaultAPCPID.Substring(0, last);
            var file = defaultAPCPID.Substring(last + 1, defaultAPCPID.Length - last - 1);
            APCPIDEditViewModel aPCPIDEditViewModel = new APCPIDEditViewModel(pix, file);
            aPCPIDEditViewModel.IsEditEnabled = false;
            var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(aPCPIDEditViewModel, null, "APC PID Table");
            if ((bool)rtn)
            {
                PressPID = aPCPIDEditViewModel.RetrunString;
            }

        }

        private bool firstUpdate = true;

        private void ClearSetValue()
        {
            TemperatureControlMode = "";
            TemperatureCorrect = "";
            TemperaturePID = "";
            ClearLoaderSetValue();
            LoaderCommand = "";
            SetShowLoaderValuePanel("None");
            PressCommand = "";
            SetShowPressPanel("None");
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);
            if (firstUpdate)
            {
                UpdateGASSetting(false);
                UpdateHeaterSetting();

                firstUpdate = false;
            }
        }


        private void UpdateGASSetting(bool upDataMfcSetPoint)
        {

            List<AITMfcData> allmfcDatas = new List<AITMfcData>()
            {
                MFC1Data,
                MFC2Data,
                MFC3Data,
                MFC4Data,
                MFC5Data,
                MFC6Data,
                MFC7Data,
                MFC8Data,
                MFC9Data,
                MFC10Data,
                MFC11Data,
                MFC12Data,
                MFC13Data,
                MFC14Data,
                MFC15Data,
                MFC16Data,
                MFC17Data,
                MFC31Data,
                MFC32Data,
                MFC51Data,
            };
            List<AITMfcData> mfcDatas = new List<AITMfcData>()
            {

            };
            foreach (var item in allmfcDatas)
            {
                if (item != null)
                {
                    mfcDatas.Add(item);
                }
            }

            if (MFCDataList.Count == 0)
            {
                for (int i = 0; i < mfcDatas.Count; i++)
                {
                    if (mfcDatas[i] == null)
                        continue;
                    double setLastPoint = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{mfcDatas[i].DeviceName}.SetLastPoint");
                    double setLastRamping = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{mfcDatas[i].DeviceName}.SetLastRamping");
                    //MFCDataList.Add(new MFCGasData()
                    //{
                    //    Name = mfcDatas[i].DeviceName,
                    //    DisplayName = mfcDatas[i].DisplayName,
                    //    ActualValue = mfcDatas[i].FeedBack,
                    //    Value = mfcDatas[i].SetPoint,
                    //    ActualRampng = mfcDatas[i].Ramping,
                    //    Rampng = mfcDatas[i].VirtualRamping,
                    //    Unit = mfcDatas[i].Unit,
                    //    AlarmValue = mfcDatas[i].AlarmWatchTable
                    //});
                    MFCDataList.Add(new MFCGasData()
                    {
                        Name = mfcDatas[i].DeviceName,
                        DisplayName = mfcDatas[i].DisplayName,
                        //ActualValue = mfcDatas[i].FeedBack,
                        Value = setLastPoint.ToString("f3"),
                        //ActualRampng = mfcDatas[i].Ramping,
                        Rampng = setLastRamping.ToString("f3"),

                        IsSetChanged = true,
                        Unit = mfcDatas[i].Unit,
                        AlarmValue = mfcDatas[i].AlarmWatchTable
                    });
                }
            }
            else
            {
                for (int i = 0; i < MFCDataList.Count; i++)
                {
                    var findMFC = mfcDatas.FirstOrDefault(x => x.DeviceName == MFCDataList[i].Name);
                    if (findMFC != null)
                    {
                        double setLastPoint = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{findMFC.DeviceName}.SetLastPoint");
                        double setLastRamping = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{findMFC.DeviceName}.SetLastRamping");
                        MFCDataList[i].Value = setLastPoint.ToString("f3");
                        MFCDataList[i].IsSetChanged = true;
                        MFCDataList[i].Rampng = setLastRamping.ToString("f3");
                    }
                };
            }
            if (MFCDataList != null && MFCDataList.Count > 0)
            {
                if (upDataMfcSetPoint)
                {
                    Dictionary<string, string> setChangedMFC = new Dictionary<string, string>();
                    foreach (var item in MFCDataList)
                    {
                        setChangedMFC.Add(item.Name, item.Value);
                    }
                    InvokeClient.Instance.Service.DoOperation($"PM1.SetAllMfcSetPoint", setChangedMFC);
                }
            }
        }

        private void UpdateHeaterSetting()
        {
            if ((HeaterUData != null && HeaterCUData != null && HeaterCData != null && HeaterCLData != null && HeaterLData != null))
            {
                List<AITHeaterData> heaterDatas = new List<AITHeaterData>()
            {
                    HeaterUData,
                    HeaterCUData,
                    HeaterCData,
                    HeaterCLData,
                    HeaterLData,
            };
                if (TempList.Count == 0)
                {
                    string[] strList = new string[5] { "BottomHeaterData", "CenterBottomHeaterData", "CenterHeaterData", "TopCenterHeaterData", "HeaterUData" };


                    for (int i = 0; i < heaterDatas.Count; i++)
                    {
                        double setLastPoint = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.Heater.{heaterDatas[i].DeviceName}.SetLastPoint");
                        double setLastRamping = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.Heater.{heaterDatas[i].DeviceName}.SetLastRamping");
                        //TempList.Add(new TempManualSetData()
                        //{
                        //    DisplayName = heaterDatas[i].DisplayName,
                        //    Name = heaterDatas[i].DeviceName,
                        //    ControlName = strList[i],
                        //    ActualValue = heaterDatas[i].FeedBack,
                        //    Value = heaterDatas[i].SetPoint,
                        //    ActualRampng = heaterDatas[i].Ramping,
                        //    Rampng = heaterDatas[i].UpRateSetPoint,
                        //    Unit = heaterDatas[i].Unit,
                        //});
                        TempList.Add(new TempManualSetData()
                        {
                            DisplayName = heaterDatas[i].DisplayName,
                            Name = heaterDatas[i].DeviceName,
                            ControlName = strList[i],
                            Value = setLastPoint.ToString("f1"),
                            Rampng = setLastRamping.ToString("f1"),
                            Unit = heaterDatas[i].Unit,
                        });
                    }
                }
                else
                {
                    for (int i = 0; i < TempList.Count; i++)
                    {
                        var findHeater = heaterDatas.FirstOrDefault(x => x.DeviceName == TempList[i].Name);
                        double setLastPoint = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.Heater.{findHeater.DeviceName}.SetLastPoint");
                        double setLastRamping = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.Heater.{findHeater.DeviceName}.SetLastRamping");
                        if (findHeater != null)
                        {
                            TempList[i].Value = setLastPoint.ToString("f1");
                            TempList[i].Rampng = setLastRamping.ToString("f1");
                            TempList[i].IsSetChanged = true;
                            TempList[i].IsRampngChanged = true;
                        }
                    };
                }
            }
        }

        public void SetValue(object sender, string isFullKeyboard = "")
        {
            string value = ((TextBox)sender).Text;
            if (!string.IsNullOrEmpty(isFullKeyboard))
            {
                FullKeyboard fullKeyboard1 = new FullKeyboard("", value);
                if ((bool)fullKeyboard1.ShowDialog())
                {
                    ((TextBox)sender).Text = fullKeyboard1.ValueString;
                }
            }
            else
            {
                NumberKeyboard fullKeyboard = new NumberKeyboard("", value);
                if ((bool)fullKeyboard.ShowDialog())
                {
                    ((TextBox)sender).Text = fullKeyboard.ValueString;
                }

            }

        }
        private string GetPressString()
        {
            string[] pressStringList = new string[4] { "", "", "", "" };
            pressStringList[0] = PressCommand;
            if (!string.IsNullOrEmpty(PressCommand))
            {
                switch (PressCommand)
                {
                    case "Press":
                    case "Press2":
                        PressVisibility = Visibility.Visible;
                        pressStringList[1] = PressPID;
                        pressStringList[2] = PressSet.ToString();
                        break;
                    case "Slow Vac":
                        var defaultAPCPID = SystemConfigProvider.Instance.GetValueByName("PM1.APCPID");
                        pressStringList[1] = defaultAPCPID;
                        pressStringList[2] = PressSlowVacSet.ToString();
                        break;
                    case "Valve Angle":
                        pressStringList[2] = PressValveAngleSet.ToString();
                        pressStringList[3] = LowPressWait;
                        break;
                    case "Full Open":
                    case "Full Close":
                    case "Hold":
                    case "Zero Set":
                    case "Cancel Zero":
                        pressStringList[1] = "";
                        pressStringList[2] = "";
                        pressStringList[3] = "";
                        break;
                    case "WaitPressUp1":
                    case "WaitPressDown1":
                    case "WaitPressUp2":
                    case "WaitPressDown2":
                        pressStringList[2] = PressWait.ToString();
                        break;
                    default:
                        break;
                }
            }
            return string.Join(";", pressStringList);
        }


    }


    public class MFCGasData : PropertyChangedBase
    {
        private int _no;

        public int No
        {
            get => _no;
            set
            {
                _no = value;
                NotifyOfPropertyChange(nameof(No));
            }
        }

        private string _name;

        public string Name
        {
            get => _name;
            set
            {
                _name = value;
                NotifyOfPropertyChange(nameof(Name));
            }
        }

        public string _unit;

        public string Unit
        {
            get => _unit;
            set
            {
                _unit = value;
                NotifyOfPropertyChange(nameof(Unit));
            }
        }

        private string _displayName;
        public string DisplayName
        {
            get => _displayName;
            set
            {
                _displayName = value;
                NotifyOfPropertyChange(nameof(DisplayName));
            }
        }

        private string _controlName;
        public string ControlName
        {
            get => _controlName;
            set
            {
                _controlName = value;
                NotifyOfPropertyChange(nameof(ControlName));
            }
        }

        private double _actualValue;
        public double ActualValue
        {
            get => _actualValue;
            set
            {
                _actualValue = value;
                NotifyOfPropertyChange(nameof(ActualValue));
            }
        }

        private string _value;
        public string Value
        {
            get => _value;
            set
            {
                _value = value;
                NotifyOfPropertyChange(nameof(Value));
            }
        }

        private double _actualRampng;

        public double ActualRampng
        {
            get => _actualRampng; set
            {
                _actualRampng = value;
                NotifyOfPropertyChange(nameof(ActualRampng));
            }
        }

        private string _rampng;

        public string Rampng
        {
            get => _rampng; set
            {
                _rampng = value;
                NotifyOfPropertyChange(nameof(Rampng));
            }
        }


        private string _maxValue;

        public string MaxValue
        {
            get => _maxValue; set
            {
                _maxValue = value;
                NotifyOfPropertyChange(nameof(MaxValue));
            }
        }

        private string _minValue;

        public string MinValue
        {
            get => _minValue; set
            {
                _minValue = value;
                NotifyOfPropertyChange(nameof(MinValue));
            }
        }

        private bool _isSetChanged = true;
        public bool IsSetChanged
        {
            get => _isSetChanged;
            set
            {
                _isSetChanged = value;
                NotifyOfPropertyChange(nameof(IsSetChanged));
            }
        }

        private bool _isRampngChanged = true;
        public bool IsRampngChanged
        {
            get => _isRampngChanged;
            set
            {
                _isRampngChanged = value;
                NotifyOfPropertyChange(nameof(IsRampngChanged));
            }
        }

        private string _alarmValue;

        public string AlarmValue
        {
            get => _alarmValue;
            set
            {
                _alarmValue = value;
                NotifyOfPropertyChange(nameof(AlarmValue));
            }
        }

    }

    public class TempManualSetData : PropertyChangedBase
    {
        private int _no;

        public int No
        {
            get => _no;
            set
            {
                _no = value;
                NotifyOfPropertyChange("No");
            }
        }


        private string _name;

        public string Name
        {
            get => _name;
            set
            {
                _name = value;
                NotifyOfPropertyChange("Name");
            }
        }

        private string _displayName;
        public string DisplayName
        {
            get => _displayName;
            set
            {
                _displayName = value;
                NotifyOfPropertyChange(nameof(DisplayName));
            }
        }

        private string _controlName;
        public string ControlName
        {
            get => _controlName;
            set
            {
                _controlName = value;
                NotifyOfPropertyChange(nameof(ControlName));
            }
        }


        private double _actualValue;
        public double ActualValue
        {
            get => _actualValue;
            set
            {
                _actualValue = value;
                NotifyOfPropertyChange(nameof(ActualValue));
            }
        }

        private string _value;
        public string Value
        {
            get => _value;
            set
            {
                _value = value;
                NotifyOfPropertyChange(nameof(Value));
            }
        }

        private string _actualRampng;

        public string ActualRampng
        {
            get => _actualRampng;
            set
            {
                _actualRampng = value;
                NotifyOfPropertyChange(nameof(ActualRampng));
            }
        }

        private string _rampng;

        public string Rampng
        {
            get => _rampng; set
            {
                _rampng = value;
                NotifyOfPropertyChange(nameof(Rampng));
            }
        }

        private string _maxValue;

        public string MaxValue
        {
            get => _maxValue; set
            {
                _maxValue = value;
                NotifyOfPropertyChange(nameof(MaxValue));
            }
        }

        private string _minValue;

        public string MinValue
        {
            get => _minValue; set
            {
                _minValue = value;
                NotifyOfPropertyChange(nameof(MinValue));
            }
        }

        private bool _isChanged = true;
        public bool IsChanged
        {
            get => _isChanged;
            set
            {
                _isChanged = value;
                NotifyOfPropertyChange(nameof(IsChanged));
            }
        }



        private string _unit;

        public string Unit
        {
            get => _unit;
            set
            {
                _unit = value;
                NotifyOfPropertyChange("Unit");
            }
        }

        private bool _isSetChanged = true;
        public bool IsSetChanged
        {
            get => _isSetChanged;
            set
            {
                _isSetChanged = value;
                NotifyOfPropertyChange(nameof(IsSetChanged));
            }
        }

        private bool _isRampngChanged = true;
        public bool IsRampngChanged
        {
            get => _isRampngChanged;
            set
            {
                _isRampngChanged = value;
                NotifyOfPropertyChange(nameof(IsRampngChanged));
            }
        }

        private string _alarmValue;

        public string AlarmValue
        {
            get => _alarmValue;
            set
            {
                _alarmValue = value;
                NotifyOfPropertyChange(nameof(AlarmValue));
            }
        }



    }

}