Kepler-Release/Venus/RecipeEditorControl/ViewModel/RecipeEditorControlViewModel.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Media;
using Venus_Core;

namespace Aitex.UI.RecipeEditor
{
    public class RecipeEditorControlViewModel : INotifyPropertyChanged
    {

        //当前选中的配方
        private Recipe m_currentRecipe;
        public Recipe CurrentRecipe
        {
            get { return m_currentRecipe; }
            set { m_currentRecipe = value; InvokePropertyChanged("CurrentRecipe"); }
        }
        
        public StackPanel GridStackPanel { get; set; }    //step容器  
        List<SolidColorBrush> solidColorBrushes = new List<SolidColorBrush>();//step模块颜色
        public StackPanel HeadStackPanel { get; set; }    //head容器

     
    

        public RecipeEditorControlViewModel()
        {           
            //solidColorBrushes.Add(new SolidColorBrush(Colors.Aqua));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.Aquamarine));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.LawnGreen));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.LightYellow));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.DarkOrange));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.MistyRose));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.BurlyWood));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.Gainsboro));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.Beige));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.Yellow));
            //solidColorBrushes.Add(new SolidColorBrush(Colors.Magenta));
        }


        public void OnAddStep()
        {
            if (CurrentRecipe != null)
            {
                RecipeStep recipeStep = new RecipeStep();
                recipeStep.LstUnit.Add(new PressureByPressureModeUnit());
                recipeStep.LstUnit.Add(new TCPUnit());
                recipeStep.LstUnit.Add(new BiasUnit());
                recipeStep.LstUnit.Add(new GasControlUnit());
                recipeStep.LstUnit.Add(new ESCHVUnit());
                recipeStep.LstUnit.Add(new ProcessKitUnit());

                CurrentRecipe.Steps.Add(recipeStep);
                var item = RecipeStepToGrid(recipeStep);
                GridStackPanel.Children.Add(item.Item1);
            }
        }

        public void OnDeleteStep()
        {
            if (CurrentRecipe != null&& CurrentRecipe.Steps.Count>0)
            {
                CurrentRecipe.Steps.RemoveAt(CurrentRecipe.Steps.Count - 1);
                GridStackPanel.Children.RemoveAt(GridStackPanel.Children.Count - 1);
            }           
        }


       /// <summary>
       /// 选中recipe，显示界面
       /// </summary>
       /// <param name="recipe"></param>
        public void LoadRecipe(Recipe recipe)
        {
            GridStackPanel.Children.Clear();
            CurrentRecipe =recipe;
            recipe.Steps.ToList().ForEach(x =>
            {
                var tupleValue = RecipeStepToGrid(x);
                GridStackPanel.Children.Add(tupleValue.Item1);
            });

            LoadHeadStackPanel(recipe);
        }
        /// <summary>
        /// 选中recipe，头部界面显示
        /// </summary>
        /// <param name="recipe"></param>
        private void LoadHeadStackPanel(Recipe recipe)
        {
            HeadStackPanel.Children.Clear();
            Type type = recipe.Header.GetType();
            foreach (var propertyInfo in type.GetProperties())
            {
                TextBlock textBlock = new TextBlock();
                textBlock.FontSize = 15;
                textBlock.Text = propertyInfo.Name + ":";
                textBlock.Margin = new Thickness(15, 0, 0, 0);
                textBlock.VerticalAlignment = VerticalAlignment.Center;
                HeadStackPanel.Children.Add(textBlock);
                Binding binding = new Binding()
                {
                    Source = recipe.Header,                // 数据源  
                    Path = new PropertyPath(propertyInfo.Name), // 需绑定的数据源属性名  
                    Mode = BindingMode.TwoWay,        // 绑定模式  
                    UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged    //触发器
                };
                var propertyTypeName = propertyInfo.PropertyType.Name;
                var propertyInfoName=propertyInfo.Name;
                Control control = new Control();

                switch (propertyTypeName)
                {
                    case "Int32":
                    case "String":
                        control = new TextBox();
                        //control.Margin = new Thickness(1, 0, 0, 0);
                        control.BorderThickness = new Thickness(0);
                        control.FontSize = 15;
                        control.Foreground = Brushes.Green;
                        control.Background = Brushes.Transparent;
                        control.VerticalAlignment = VerticalAlignment.Center;
                        control.MinWidth = 15;
                        control.SetBinding(TextBox.TextProperty, binding);
                        if (propertyInfoName == "Name" || propertyInfoName == "CreateTime" || propertyInfoName == "LastModifiedBy")
                        {
                            (control as TextBox).IsReadOnly = true;
                        }
                        break;

                    case "Boolean":
                        control = new CheckBox();
                        control.SetBinding(CheckBox.IsCheckedProperty, binding);
                        break;

                    default:
                        control = new ComboBox();
                        control.Height = 25;
                        control.SetBinding(ComboBox.SelectedItemProperty, binding);
                        ItemsControlHelper.SetEnumValuesToItemsSource(control, true);
                        break;
                }
                HeadStackPanel.Children.Add(control);
            }
        }

        /// <summary>
        /// step转换为Grid
        /// </summary>
        /// <param name="recipeStep"></param>
        /// <returns></returns>
        private ValueTuple<Grid, List<int>> RecipeStepToGrid(RecipeStep recipeStep)
        {
            Grid grid = new Grid();
            List<int> ints = new List<int>();

            ColumnDefinition col1 = new ColumnDefinition();//Key
            ColumnDefinition col2 = new ColumnDefinition();//Value
            grid.ColumnDefinitions.Add(col1);
            grid.ColumnDefinitions.Add(col2);
            GridOptions.SetShowBorder(grid, true);
            GridOptions.SetLineBrush(grid, Brushes.White);
            GridOptions.SetLineThickness(grid, 1);
            grid.Margin = new Thickness(15, 0, 0, 0);

            Type recipeType = recipeStep.GetType();
            int i = 0;
            foreach (PropertyInfo propertyInfo in recipeType.GetProperties())
            {
                string propertyInfoName  = propertyInfo.Name;
                string propertyTypeName  = propertyInfo.PropertyType.Name;
                if (propertyInfoName != "LstUnit")
                {
                    RowDefinition row1 = new RowDefinition();
                    grid.RowDefinitions.Add(row1);

                    Binding binding = new Binding()
                    {
                        Source = recipeStep,                // 数据源  
                        Path = new PropertyPath(propertyInfoName), // 需绑定的数据源属性名  
                        Mode = BindingMode.TwoWay,        // 绑定模式  
                        UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged    //触发器
                    };
                    switch (propertyTypeName)
                    {
                        case "Int32":
                        case "String":
                            TextBox textBox = new TextBox();                          
                            textBox.SetBinding(TextBox.TextProperty, binding);
                            grid.Children.Add(textBox);
                            Grid.SetRow(textBox, i);
                            Grid.SetColumn(textBox, 1);
                            break;

                        case "Boolean":
                            CheckBox checkBox = new CheckBox();
                            checkBox.SetBinding(CheckBox.IsCheckedProperty, binding);
                            grid.Children.Add(checkBox);
                            Grid.SetRow(checkBox, i);
                            Grid.SetColumn(checkBox, 1);
                            break;

                        default:
                            ComboBox comboBox = new ComboBox();
                            comboBox.SetBinding(ComboBox.SelectedItemProperty, binding);
                            ItemsControlHelper.SetEnumValuesToItemsSource(comboBox, true);
                            grid.Children.Add(comboBox);
                            Grid.SetRow(comboBox, i);
                            Grid.SetColumn(comboBox, 1);
                            if (propertyInfo.Name == "PressureUnitMode")
                            {
                                comboBox.SelectionChanged += ComboBox_SelectionChanged;
                            }
                            break;

                    }

                    TextBlock textBlock = new TextBlock();
                    textBlock.Text = propertyInfoName;
                    grid.Children.Add(textBlock);

                    Grid.SetRow(textBlock, i);
                    Grid.SetColumn(textBlock, 0);
                    i++;
                }

            }
            ints.Add(recipeType.GetProperties().Length);
            int k = 0;
            recipeStep.LstUnit.ToList().ForEach(x =>
            {
                Type unitType = x.GetType();
                foreach (PropertyInfo propertyInfo in unitType.GetProperties())
                {
                    Binding binding = new Binding()
                    {
                        Source = recipeStep.LstUnit[k],                // 数据源  
                        //Path = new PropertyPath($"LstUnit[{k}]." + propertyInfo.Name), // 需绑定的数据源属性名  
                        Path = new PropertyPath(propertyInfo.Name), // 需绑定的数据源属性名  

                        Mode = BindingMode.TwoWay,        // 绑定模式  
                        UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged    //触发器
                    };
                    RowDefinition row1 = new RowDefinition();
                    grid.RowDefinitions.Add(row1);
                    var item = propertyInfo.PropertyType.Name;
                    if (propertyInfo.Name == "UnitName")
                    {
                        TextBlock textBlock1 = new TextBlock();

                        //textBlock1.SetBinding(TextBlock.TextProperty, binding);
                        textBlock1.Text = propertyInfo.GetValue(x).ToString();
                        textBlock1.Foreground = Brushes.Red;
                        //textBlock1.HorizontalAlignment = HorizontalAlignment.Center;
                        grid.Children.Add(textBlock1);
                        Grid.SetRow(textBlock1, i);
                        Grid.SetColumn(textBlock1, 1);
                    }
                    else
                    {
                        switch (item)
                        {
                            case "Int32":
                            case "String":
                                TextBox textBox = new TextBox();
                                textBox.BorderBrush = Brushes.Transparent;
                                textBox.SetBinding(TextBox.TextProperty, binding);
                                grid.Children.Add(textBox);
                                Grid.SetRow(textBox, i);
                                Grid.SetColumn(textBox, 1);
                                break;

                            case "Boolean":
                                CheckBox checkBox = new CheckBox();
                                checkBox.SetBinding(CheckBox.IsCheckedProperty, binding);
                                grid.Children.Add(checkBox);
                                Grid.SetRow(checkBox, i);
                                Grid.SetColumn(checkBox, 1);
                                break;

                            default:
                                ComboBox comboBox = new ComboBox();
                                comboBox.BorderBrush = Brushes.Transparent;
                                //comboBox.Background = Brushes.White;
                                string path = propertyInfo.Name;
                                comboBox.SetBinding(ComboBox.SelectedItemProperty, binding);
                                ItemsControlHelper.SetEnumValuesToItemsSource(comboBox, true);
                                grid.Children.Add(comboBox);
                                Grid.SetRow(comboBox, i);
                                Grid.SetColumn(comboBox, 1);
                                break;
                        }
                    }
                    TextBlock textBlock = new TextBlock();
                    textBlock.Text = propertyInfo.Name;
                    grid.Children.Add(textBlock);
                    Grid.SetRow(textBlock, i);
                    Grid.SetColumn(textBlock, 0);
                    i++;
                }
                ints.Add(unitType.GetProperties().Length);
                k++;
            });
            return new ValueTuple<Grid, List<int>>(grid, ints);
        }

        private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.RemovedItems.Count > 0)
            {
                ComboBox comboBox = sender as ComboBox;
                Grid grid = GetParentObject<Grid>(comboBox, "");
                int index= GridStackPanel.Children.IndexOf(grid);
                RecipeStep recipeStep = CurrentRecipe.Steps[index];
                recipeStep.LstUnit.RemoveAt(0);
                if (comboBox.SelectedIndex == 0)
                {
                    recipeStep.LstUnit.Insert(0, new PressureByPressureModeUnit());
                }
                else
                {
                    recipeStep.LstUnit.Insert(0, new PressureByValveModeUnit());
                }
                GridStackPanel.Children.Remove(grid);
                GridStackPanel.Children.Insert(index, RecipeStepToGrid(recipeStep).Item1);
            }
        }

        /// <summary>
        /// 获取父控件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public T GetParentObject<T>(DependencyObject obj, string name) where T : FrameworkElement
        {
            DependencyObject parent = VisualTreeHelper.GetParent(obj);
            while (parent != null)
            {
                if (parent is T && (((T)parent).Name == name || string.IsNullOrEmpty(name)))
                {
                    return (T)parent;
                }
                parent = VisualTreeHelper.GetParent(parent);
            }
            return null;
        }

        private Tuple<DataGrid,List<int>> RecipeStepToDataGrid(RecipeStep recipeStep)
        {
            DataGrid dataGrid = new DataGrid();
            List<int> ints = new List<int>();
            DataTable dataTable = new DataTable();
            dataTable.Columns.Add("Key");
            dataTable.Columns.Add("Value");
            dataGrid.CanUserAddRows = false;
            dataGrid.AutoGenerateColumns = true;       
            dataGrid.SelectionUnit = DataGridSelectionUnit.Cell;
            dataGrid.SetValue(System.Windows.Controls.VirtualizingStackPanel.IsVirtualizingProperty, false);
            Type recipeType = recipeStep.GetType();
            foreach (PropertyInfo propertyInfo in recipeType.GetProperties())
            {
                if (propertyInfo.Name != "LstUnit")
                {
                    dataTable.Rows.Add(propertyInfo.Name, propertyInfo.GetValue(recipeStep));
                }
            }
            ints.Add(dataTable.Rows.Count);
            
            recipeStep.LstUnit.ToList().ForEach(k =>
            {
                //List<dynamic> dynamics = new List<dynamic>();
                Type type = k.GetType();
                ints.Add(type.GetProperties().Length);
                foreach (PropertyInfo propertyInfo in type.GetProperties())
                {
                    var name = propertyInfo.Name;
                    var value = propertyInfo.GetValue(k);
                        //dynamicModel.PropertyName = name;
                        //dynamicModel.Property = value;
                    dataTable.Rows.Add(name, value);
                }
            });
            dataGrid.ItemsSource = dataTable.DefaultView;
            //});
            return new Tuple<DataGrid, List<int>>(dataGrid, ints);

        }
        private void ChangeDataGridRowColor(DataGrid dataGrid,List<int> ints)
        {
            int count = 0;
            for (int i = 0; i < ints.Count; i++)
            {
                for (int j = 0; j < ints[i]; j++)
                {
                    dataGrid.UpdateLayout();
                    int index = count + j;
                    DataGridRow row = dataGrid.ItemContainerGenerator.ContainerFromItem(dataGrid.Items[index]) as DataGridRow;
                    row.Background = solidColorBrushes[i];
                }
                count += ints[i];
            }
        }     
        private void ChangeGridRowColor(Grid grid, List<int> ints)
        {
            int count = 0;
            for (int i = 0; i < ints.Count; i++)
            {
                for (int j = 0; j < ints[i]; j++)
                {
                    //dataGrid.UpdateLayout();
                    int index = count + j;
                    //DataGridRow row = dataGrid.ItemContainerGenerator.ContainerFromItem(dataGrid.Items[index]) as DataGridRow;
                    //grid.RowDefinitions[index]
                }
                count += ints[i];
            }
        }


        #region 旧代码
        /// <summary>
        /// Open local recipe operation
        /// </summary>
        /// <param name="recipeDefineFilePath"></param>
        //public void OpenLocalRecipe(string recipeVariationName = "")
        //{
        //    var dlg = new OpenFileDialog();
        //    dlg.DefaultExt = ".rcp";
        //    dlg.Filter = "Recipe File (.rcp)|*.rcp|All (*.*)|*.*";
        //    if (dlg.ShowDialog() == true)
        //    {
        //        try
        //        {
        //            XmlDocument rcpDoc = new XmlDocument();
        //            rcpDoc.Load(dlg.FileName);
        //            string recipeVariation = recipeVariationName;
        //            if (string.IsNullOrEmpty(recipeVariation))
        //            {
        //                var root = rcpDoc.SelectSingleNode("/TableRecipeData") as XmlElement;
        //                recipeVariation = root.Attributes["RecipeVersion"].Value;
        //            }

        //            var startupPath = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
        //            string dir = System.IO.Path.GetDirectoryName(startupPath);

        //            List<Aitex.Controls.RecipeCompare.Item> map = CustomXmlSerializer.Deserialize<List<Aitex.Controls.RecipeCompare.Item>>(new System.IO.FileInfo(System.IO.Path.Combine(dir, "map.xml")));

        //            Func<Aitex.Controls.RecipeCompare.Item, bool> predicate = item => item.Name.Equals(recipeVariation);

        //            System.IO.FileInfo fi = new System.IO.FileInfo(string.Format("{0}\\config\\{1}.xml", dir, map.Any(predicate) ? map.Single(predicate).No : recipeVariation));

        //            if (fi.Exists)
        //            {
        //                XmlDocument doc = new XmlDocument();
        //                doc.Load(fi.FullName);

        //                string formatXml = doc.SelectSingleNode("/Aitex/TableRecipeFormat").OuterXml;
        //                string recipeXml = rcpDoc.SelectSingleNode("/TableRecipeData").OuterXml;
        //                //LoadRecipe(formatXml, recipeXml);
        //                if (OnLocalRecipeOpened != null)
        //                    OnLocalRecipeOpened.Invoke(new Tuple<string, string>(recipeVariation, dlg.FileName), null);
        //            }
        //            else
        //            {
        //                MessageBox.Show(string.Format("工艺程序版本{0}的描述文件不存在，无法正确识别该版本的工艺程序文件。", recipeVariation), "工艺程序打开失败",
        //                     MessageBoxButton.OK, MessageBoxImage.Error);
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            System.Diagnostics.Debug.WriteLine(ex.Message);
        //            MessageBox.Show(string.Format("open recipe {0} failed，please confirm the recipe file is exist and valid。\r\n{1}", dlg.FileName, ex.Message), "Open recipe failed",
        //                 MessageBoxButton.OK, MessageBoxImage.Error);
        //        }
        //    }
        //}

        /// <summary>
        /// Save recipe file
        /// </summary>
        //private void SaveRecipeFile()
        //{
        //    //try
        //    //{
        //    //    if (Errors != null && Errors.Count > 0)
        //    //    {
        //    //        var ret = MessageBox.Show(string.Format("Recipe have {0} error，continue save？", Errors.Count), "Save", MessageBoxButton.YesNo, MessageBoxImage.Warning, MessageBoxResult.No);
        //    //        if (ret != MessageBoxResult.Yes)
        //    //            return;
        //    //    }
        //    //    if (OnSaveRecipeFile != null)
        //    //    {
        //    //        IsRecipeModified = false;

        //    //    }
        //    //}
        //    //catch (Exception ex)
        //    //{
        //    //    System.Diagnostics.Debug.WriteLine(ex.Message);
        //    //    MessageBox.Show("save recipe failed！\r\n\r\n" + ex.Message, "Save", MessageBoxButton.OK, MessageBoxImage.Warning);
        //    //}
        //}
        /// <summary>
        /// calc recipe total time
        /// </summary>
        private void CalcRecipeTime()
        {
            //int timeStepRowId = -1;
            //int loopStepRowId = -1;
            //for (int i = 0; i < RecipeRows.Count; i++)
            //{
            //    if (RecipeRows[i].TechnicalName == "Time")
            //        timeStepRowId = i;
            //    if (RecipeRows[i].TechnicalName == "Loop")
            //        loopStepRowId = i;
            //    if (loopStepRowId != -1 && timeStepRowId != -1)
            //        break;
            //}
            //TimeSpan tspan = new TimeSpan();
            //for (int stepNo = 0; stepNo < RecipeRows[timeStepRowId].RecipeItems.Count; stepNo++)
            //{
            //    string loopStr = RecipeRows[loopStepRowId].RecipeItems[stepNo].Value;
            //    bool isLoopStart = Regex.IsMatch(loopStr, @"^Loop\x20\d+$");
            //    if (isLoopStart)
            //    {
            //        int loopNum = int.Parse(loopStr.ToLower().Replace("loop", "").Replace(" ", ""));
            //        TimeSpan ts = new TimeSpan();
            //        for (int innerStepNo = stepNo; innerStepNo < RecipeRows[timeStepRowId].RecipeItems.Count; innerStepNo++)
            //        {
            //            loopStr = RecipeRows[loopStepRowId].RecipeItems[innerStepNo].Value;
            //            stepNo = innerStepNo;
            //            string timeDuration = RecipeRows[timeStepRowId].RecipeItems[innerStepNo].Value;
            //            string[] timeArr = timeDuration.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
            //            if (timeArr.Length == 3)
            //            {
            //                int h, mi, s;
            //                if (int.TryParse(timeArr[0], out h) && int.TryParse(timeArr[1], out mi) && int.TryParse(timeArr[2], out s))
            //                {
            //                    var tt = new TimeSpan(h, mi, s);
            //                    ts += tt;
            //                }
            //            }
            //            bool isLoopEnd = Regex.IsMatch(loopStr, @"^Loop End$");
            //            if (isLoopEnd)
            //            {
            //                tspan += new TimeSpan(ts.Ticks * loopNum);
            //                break;
            //            }
            //        }
            //    }
            //    else
            //    {
            //        string timeDuration = RecipeRows[timeStepRowId].RecipeItems[stepNo].Value;
            //        string[] timeArr = timeDuration.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
            //        if (timeArr.Length == 3)
            //        {
            //            int h, mi, s;
            //            if (int.TryParse(timeArr[0], out h) && int.TryParse(timeArr[1], out mi) && int.TryParse(timeArr[2], out s))
            //            {
            //                var ts = new TimeSpan(h, mi, s);
            //                tspan += ts;
            //            }
            //        }
            //    }
            //}
            //RecipeInfo = string.Format("共{0}步，总时间{1}:{2}:{3}", RecipeRows[0].RecipeItems.Count, (int)tspan.TotalHours, tspan.Minutes.ToString("00"), tspan.Seconds.ToString("00"));
            //InvokePropertyChanged("RecipeInfo");
        }

        #region INotifyPropertyChanged

        public event PropertyChangedEventHandler PropertyChanged;

        public void InvokePropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        #endregion INotifyPropertyChanged
    }


    //public class RecipeRow
    //{
    //    //private ObservableCollection<SmartCellData> _recipeItems = new ObservableCollection<SmartCellData>();

    //    //public RecipeRow(params SmartCellData[] vars)
    //    //{
    //    //    foreach (var var in vars)
    //    //        _recipeItems.Add(var);
    //    //}

    //    //public string CatalogName { get; set; }

    //    //public string FriendlyName { get; set; }

    //    //public string TechnicalName { get; set; }

    //    //public ObservableCollection<SmartCellData> RecipeItems
    //    //{
    //    //    get { return _recipeItems; }
    //    //    set { _recipeItems = value; }
    //    //}
    //}

    ///// <summary>
    ///// Recipe head
    ///// </summary>
    //public class RecipeHead
    //{
    //    //public string RecipeVariation { get; set; }
    //    //public string CreationTime { get; set; }
    //    //public string LastRevisionTime { get; set; }
    //    //public string CreatedBy { get; set; }
    //    //public string LastModifiedBy { get; set; }
    //    //public string PressureMode { get; set; }
    //    //public string Description { get; set; }

    //    //public string BasePressure
    //    //{
    //    //    get; set;
    //    //}

    //    //public string PumpDownLimit
    //    //{
    //    //    get; set;
    //    //}

    //    //public string PurgeActive
    //    //{
    //    //    get; set;
    //    //}

    //    //public string NotToPurgeOrVent
    //    //{
    //    //    get; set;
    //    //}

    //    //public string Barcode
    //    //{
    //    //    get; set;
    //    //}

    //    //public string SubstrateTemp
    //    //{
    //    //    get; set;
    //    //}

    //    //public string PumpingPinState
    //    //{
    //    //    get; set;
    //    //}

    //    //public string VentingPinState
    //    //{
    //    //    get; set;
    //    //}

    //    //public string PinDownPressure
    //    //{
    //    //    get; set;
    //    //}
    //}


    //public class EndPointConfigItem : INotifyPropertyChanged
    //{
    //    public event PropertyChangedEventHandler PropertyChanged;

    //    public void InvokePropertyChanged(string propertyName)
    //    {
    //        if (PropertyChanged != null)
    //        {
    //            PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
    //        }
    //    }

    //    //public string ExposureTime { get; set; }

    //    //public string WaveLengthA { get; set; }
    //    //public string BinningA { get; set; }

    //    //public string WaveLengthB { get; set; }
    //    //public string BinningB { get; set; }

    //    //public string WaveLengthC { get; set; }
    //    //public string BinningC { get; set; }

    //    //public string WaveLengthD { get; set; }
    //    //public string BinningD { get; set; }

    //    //public string Fd { get; set; }
    //    //public string PrefilterTime { get; set; }
    //    //public string PostfilterTime { get; set; }
    //    //public string AlgorithmType { get; set; }
    //    //public string Criteria { get; set; }
    //    //public string DelayTime { get; set; }
    //    //public string ValidationTime { get; set; }
    //    //public string ValidationValue { get; set; }
    //    //public string TimeWindow { get; set; }

    //    //public string MinimalTime { get; set; }
    //    //public string PostponeTime { get; set; }

    //    //public bool Control { get; set; }
    //    //public bool Normalization { get; set; }
    //    //public bool EnablePostponePercent { get; set; }
    //    //public bool EnableCriterialPercent { get; set; }

    //    //public bool EnableEventTrigger { get; set; }
    //    //public bool IsFaultIfNoTrigger { get; set; }


    //    //public string ToValue()
    //    //{
    //    //    return
    //    //        $@"ExposureTime={ExposureTime};WaveLengthA={WaveLengthA};BinningA={BinningA};WaveLengthB={WaveLengthB};" +
    //    //        $@"BinningB={BinningB};WaveLengthC={WaveLengthC};BinningC={BinningC};WaveLengthD={WaveLengthD};BinningD={BinningD};Fd={Fd};" +
    //    //        $@"PrefilterTime={PrefilterTime};PostfilterTime={PostfilterTime};AlgorithmType={AlgorithmType};Criteria={Criteria};DelayTime={DelayTime};ValidationTime={ValidationTime};" +
    //    //        $@"ValidationValue={ValidationValue};TimeWindow={TimeWindow};MinimalTime={MinimalTime};PostponeTime={PostponeTime};Control={Control};Normalization={Normalization};" +
    //    //        $@"EnablePostponePercent={EnablePostponePercent};EnableCriterialPercent={EnableCriterialPercent};EnableEventTrigger={EnableEventTrigger};IsFaultIfNoTrigger={IsFaultIfNoTrigger};"
    //    //        ;
    //    //}

    //    //public void SetValue(string config)
    //    //{
    //    //    if (string.IsNullOrEmpty(config))
    //    //        return;

    //    //    string[] items = config.Split(';');
    //    //    foreach (var item in items)
    //    //    {
    //    //        if (string.IsNullOrEmpty(item))
    //    //            continue;

    //    //        string[] pairs = item.Split('=');
    //    //        if (pairs.Length != 2)
    //    //            continue;

    //    //        Parallel.ForEach(this.GetType().GetProperties(),
    //    //            property =>
    //    //            {
    //    //                PropertyInfo pi = (PropertyInfo) property;
    //    //                if (pi.Name == pairs[0])
    //    //                {
    //    //                    try
    //    //                    {
    //    //                        var convertedValue = Convert.ChangeType(pairs[1], pi.PropertyType);
    //    //                        var originValue = Convert.ChangeType(pi.GetValue(this, null), pi.PropertyType);
    //    //                        if (originValue != convertedValue)
    //    //                        {
    //    //                            pi.SetValue(this, convertedValue, null);
    //    //                        }
    //    //                    }
    //    //                    catch (Exception)
    //    //                    {

    //    //                    }
    //    //                }
    //    //            });
    //    //    }
    //    //}
    //}
    #endregion

}