PunkHPX8/PunkHPX8_MainPages/ViewModels/VpwRecipeViewModel.cs

using Aitex.Core.UI.MVVM;
using Aitex.Core.Utilities;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Utilities;

using Prism.Mvvm;
using PunkHPX8_Core;
using PunkHPX8_MainPages.PMs;
using PunkHPX8_Themes.UserControls;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace PunkHPX8_MainPages.ViewModels
{
    public class VpwRecipeViewModel : BindableBase
    {
        private const string ENGINEERING = "Engineering";

        #region 内部变量
        private Dictionary<string, RecipeNode> _recipeNodeDic = new Dictionary<string, RecipeNode>();
        private ObservableCollection<RecipeNode> _recipeNodes;
        private UiRecipeManager _uiRecipeManager = new UiRecipeManager();
        private Dictionary<string, bool> _propertyValidResultDic = new Dictionary<string, bool>();
        private VpwRecipe _recipe;
        private bool _editEnable;
        private bool _createEnable;
        private RecipeNode _currentNode;
        private bool _enable = false;
        private bool _isEdit = false;
        /// <summary>
        /// Wafer尺寸集合
        /// </summary>
        private List<int> _waferSizeLst = null;
        /// <summary>
        /// Vacuum Prewet step选择索引
        /// </summary>
        private int _selectedVacuumPrewetIndex = -1;
        /// <summary>
        /// Extend Clean step选择索引
        /// </summary>
        private int _selectedExtendCleanIndex = -1;
        /// <summary>
        /// Vent Prewet step选择索引
        /// </summary>
        private int _selectedVentPrewetIndex = -1;
        #endregion

        #region 属性
        public ObservableCollection<RecipeNode> RecipeNodes
        {
            get { return _recipeNodes; }
            set { SetProperty(ref _recipeNodes, value); }
        }
        public Dictionary<string, bool> PropertyValidResultDic
        {
            get { return _propertyValidResultDic; }
            set { SetProperty(ref _propertyValidResultDic, value); }
        }
        public RecipeNode CurrentNode
        {
            get { return _currentNode; }
            set { SetProperty(ref _currentNode, value); }
        }
        public bool Enable
        {
            get { return _enable; }
            set { SetProperty(ref _enable, value); }
        }
        public bool EditEnable
        {
            get { return _editEnable; }
            set { SetProperty(ref _editEnable, value); }
        }
        public bool CreateEnable
        {
            get { return _createEnable; }
            set { SetProperty(ref _createEnable, value); }
        }

        public VpwRecipe Recipe
        {
            get { return _recipe; }
            set { SetProperty(ref _recipe, value); }
        }
        /// <summary>
        /// Wafer 尺寸集合
        /// </summary>
        public List<int> WaferSizeLst
        {
            get { return _waferSizeLst; }
            set { SetProperty(ref _waferSizeLst, value); }
        }
        /// <summary>
        /// Vacuum Prewet step选择索引
        /// </summary>
        public int SelectedVacuumPrewetIndex
        {
            get { return _selectedVacuumPrewetIndex; }
            set { SetProperty(ref _selectedVacuumPrewetIndex, value); }
        }
        /// <summary>
        /// SelectedExtendCleanIndex选择索引
        /// </summary>
        public int SelectedExtendCleanIndex
        {
            get { return _selectedExtendCleanIndex; }
            set { SetProperty(ref _selectedExtendCleanIndex, value); }
        }
        /// <summary>
        /// SelectedVentPrewetIndex选择索引
        /// </summary>
        public int SelectedVentPrewetIndex
        {
            get { return _selectedVentPrewetIndex; }
            set { SetProperty(ref _selectedVentPrewetIndex, value); }
        }
        #region 指令
        public ICommand OperationCommand
        {
            get;
            private set;
        }
        [IgnorePropertyChange]
        public ICommand CreateCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand EditCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand SaveRecipeCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand SaveAsRecipeCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand IsSprayBarRetractFalseCommand { get; private set; }

        [IgnorePropertyChange]
        public ICommand AddBelowCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand AddAboveCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand MoveUpCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand MoveDownCommand { get; private set; }

        [IgnorePropertyChange]
        public ICommand DeleteCommand { get; private set; }

        public ICommand VentPrewetAddBelowCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand VentPrewetAddAboveCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand VentPrewetMoveUpCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand VentPrewetMoveDownCommand { get; private set; }

        [IgnorePropertyChange]
        public ICommand VentPrewetDeleteCommand { get; private set; }

        public ICommand ExtendCleanAddBelowCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand ExtendCleanAddAboveCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand ExtendCleanMoveUpCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand ExtendCleanMoveDownCommand { get; private set; }

        [IgnorePropertyChange]
        public ICommand ExtendCleanDeleteCommand { get; private set; }
        #endregion

        public VpwRecipeViewModel()
        {
            OperationCommand = new DelegateCommand<object>(SelectionChangedAction);
            CreateCommand = new DelegateCommand<object>(CreateAction);
            EditCommand = new DelegateCommand<object>(EditAction);
            SaveRecipeCommand = new DelegateCommand<object>(SaveAction);
            SaveAsRecipeCommand = new DelegateCommand<object>(SaveAsAction);
            IsSprayBarRetractFalseCommand = new DelegateCommand<object>(IsSprayBarRetractFalseAction);

            AddBelowCommand = new DelegateCommand<object>(AddBelowAction);
            AddAboveCommand = new DelegateCommand<object>(AddAboveAction);
            MoveUpCommand = new DelegateCommand<object>(MoveUpAction);
            MoveDownCommand = new DelegateCommand<object>(MoveDownAction);
            DeleteCommand = new DelegateCommand<object>(DeleteAction);

            VentPrewetAddBelowCommand = new DelegateCommand<object>(VentPrewetAddBelowAction);
            VentPrewetAddAboveCommand = new DelegateCommand<object>(VentPrewetAddAboveAction);
            VentPrewetMoveUpCommand = new DelegateCommand<object>(VentPrewetMoveUpAction);
            VentPrewetMoveDownCommand = new DelegateCommand<object>(VentPrewetMoveDownAction);
            VentPrewetDeleteCommand = new DelegateCommand<object>(VentPrewetDeleteAction);

            ExtendCleanAddBelowCommand = new DelegateCommand<object>(ExtendCleanAddBelowAction);
            ExtendCleanAddAboveCommand = new DelegateCommand<object>(ExtendCleanAddAboveAction);
            ExtendCleanMoveUpCommand = new DelegateCommand<object>(ExtendCleanMoveUpAction);
            ExtendCleanMoveDownCommand = new DelegateCommand<object>(ExtendCleanMoveDownAction);
            ExtendCleanDeleteCommand = new DelegateCommand<object>(ExtendCleanDeleteAction);

            //Wafer尺寸集合
            WaferSizeLst = new List<int>();
            WaferSizeLst.Add(100);
            WaferSizeLst.Add(150);
            WaferSizeLst.Add(200);
            WaferSizeLst.Add(300);

            InitializeProprtyValidResultDictionary();
        }
        #endregion
        private void InitializeProprtyValidResultDictionary()
        {
            //需要检验的参数
            PropertyValidResultDic["VacuumTarget"] = false;
            PropertyValidResultDic["DryHoldTime"] = false;
            PropertyValidResultDic["DiwLoopDoSet"] = false;
            PropertyValidResultDic["SpinSpeed"] = false;
            PropertyValidResultDic["SpinTime"] = false;
        }

        public void LoadRecipeData()
        {
            RecipeNodes = _uiRecipeManager.GetRecipesByType("vpw");
            _recipeNodeDic.Clear();
            InitializeDictionary(RecipeNodes);
        }

        private void InitializeDictionary(ObservableCollection<RecipeNode> nodes)
        {
            if (nodes != null)
            {
                foreach (var node in nodes)
                {
                    if (node.NodeType == RecipeNodeType.File)
                    {
                        _recipeNodeDic[node.Name] = node;
                    }
                    InitializeDictionary(node.Children);
                }
            }
        }

        private void SelectionChangedAction(object param)
        {
            if (_recipeNodeDic.ContainsKey(param.ToString()))
            {
                CurrentNode = _recipeNodeDic[param.ToString()];
                if (CurrentNode.NodeType == RecipeNodeType.File)
                {
                    if (CurrentNode.RecipeLocation == ENGINEERING)
                    {
                        EditEnable = true;
                        CreateEnable = true;
                    }
                    else
                    {
                        EditEnable = false;
                        CreateEnable = false;
                    }
                }
                Recipe = _uiRecipeManager.LoadRecipe<VpwRecipe>(CurrentNode.RecipeFullFileName);
                if (Recipe == null)
                {
                    MessageBox.Show("Invalid Recipe", "Load Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    EditEnable = false;
                    CreateEnable = false;
                }
                Enable = false;
            }
            else
            {
                if (param.ToString() == ENGINEERING)
                {
                    CreateEnable = true;
                }
                else
                {
                    CreateEnable = false;
                }
                CurrentNode = null;
                Recipe = null;
                EditEnable = false;
                Enable = false;
            }
        }

        private void CreateAction(object param)
        {
            RecipeNameDialog recipeNameDialog = new RecipeNameDialog();
            if (recipeNameDialog.ShowDialog().Value)
            {
                if (!CheckNameExist(recipeNameDialog.RecipeName))
                {
                    Recipe = new VpwRecipe();
                    Recipe.CreateDate = DateTime.Now;
                    Recipe.Ppid = recipeNameDialog.RecipeName;
                    Recipe.Description = recipeNameDialog.RecipeDescription;
                    Recipe.VacuumRinseStep = new ObservableCollection<VpwRinseStep>();
                    Recipe.VentRinseStep = new ObservableCollection<VpwRinseStep>();
                    Recipe.ExtendCleanRinseStep = new ObservableCollection<VpwRinseStep>();
                    Enable = true;
                    _isEdit = false;
                }
            }
        }
        private void EditAction(object param)
        {
            Enable = true;
            _isEdit = false;
        }
        private void SaveAction(object param)
        {
            if (CheckValid(_isEdit))
            {
                Recipe.SaveDate = DateTime.Now;
                try
                {
                    _uiRecipeManager.SaveRecipe<VpwRecipe>(ENGINEERING, Recipe.Ppid, "vpw", Recipe);
                    LoadRecipeData();
                    MessageBox.Show("Save Recipe Success", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Information);
                    Enable = false;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
        /// <summary>
        /// 另存为
        /// </summary>
        /// <param name="param"></param>
        private void SaveAsAction(object param)
        {
            if (Recipe == null)
            {
                MessageBox.Show("Select a Recipe first", "SaveAs Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            VpwRecipe recipe = new VpwRecipe();
            if (CheckValid(_isEdit))
            {
                RecipeNameDialog recipeNameDialog = new RecipeNameDialog();
                if (recipeNameDialog.ShowDialog().Value)
                {
                    if (!CheckNameExist(recipeNameDialog.RecipeName))
                    {
                        recipe = new VpwRecipe();

                        recipe = (VpwRecipe)PropertyUtil.Clone(Recipe);
                        recipe.CreateDate = DateTime.Now;
                        recipe.Ppid = recipeNameDialog.RecipeName;
                        recipe.Description = recipeNameDialog.RecipeDescription;

                    }
                    else if (recipeNameDialog.RecipeName != null)
                    {
                        MessageBox.Show("Name can not be Null", "Create Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                    }
                    else
                    {
                        return;
                    }
                }
                try
                {
                    _uiRecipeManager.SaveRecipe<VpwRecipe>(ENGINEERING, recipe.Ppid, "vpw", recipe);
                    LoadRecipeData();
                    MessageBox.Show("Save As Recipe Success", "SaveAs Recipe", MessageBoxButton.OK, MessageBoxImage.Information);
                    Enable = false;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Save As Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }

        private bool CheckNameExist(string name)
        {
            foreach (string item in _recipeNodeDic.Keys)
            {
                if (item == name)
                {
                    MessageBox.Show($"{name} is exsit", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    return true;
                }
            }
            return false;
        }

        private bool CheckValid(bool editType)
        {
            foreach (string key in _propertyValidResultDic.Keys)
            {
          
                bool valid = _propertyValidResultDic[key];
                if (!valid)
                {
                    MessageBox.Show($"{key} data invalid", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    return false;
                }
            }
            return true;
        }

        private void IsSprayBarRetractFalseAction(object param)
        {
            Recipe.IsSprayBarRetract = false;
        }


        #region Vacuum prewet按钮
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="param"></param>
        private void AddBelowAction(object param)
        {
            if (Recipe != null)
            {
                VpwRinseStep currentRinseSteps = new VpwRinseStep();
                
                currentRinseSteps.Index = SelectedVacuumPrewetIndex + 1;
                for(int i = currentRinseSteps.Index; i<=Recipe.VacuumRinseStep.Count-1; i++)
                {
                    Recipe.VacuumRinseStep[i].Index++;
                }

                Recipe.VacuumRinseStep.Insert(SelectedVacuumPrewetIndex + 1, currentRinseSteps);
                SelectedVacuumPrewetIndex++;
            }

        }
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="param"></param>
        private void AddAboveAction(object param)
        {
            if (Recipe != null)
            {
                VpwRinseStep currentRinseSteps = new VpwRinseStep();
                if (SelectedVacuumPrewetIndex == -1)
                {
                    Recipe.VacuumRinseStep.Add(currentRinseSteps);
                    SelectedVacuumPrewetIndex = 0;
                }
                else
                {
                    currentRinseSteps.Index = SelectedVacuumPrewetIndex;
                    for (int i = currentRinseSteps.Index; i <= Recipe.VacuumRinseStep.Count-1; i++)
                    {
                        Recipe.VacuumRinseStep[i].Index++;
                    }

                    Recipe.VacuumRinseStep.Insert(SelectedVacuumPrewetIndex, currentRinseSteps);
                    SelectedVacuumPrewetIndex--;
                }
            }
        }
        /// <summary>
        /// 上移
        /// </summary>
        /// <param name="param"></param>
        private void MoveUpAction(object param)
        {
            if (Recipe != null)
            {
                if (SelectedVacuumPrewetIndex > 0)
                {
                    int currentIndex = SelectedVacuumPrewetIndex;
                    VpwRinseStep currentRinseSteps = Recipe.VacuumRinseStep[SelectedVacuumPrewetIndex];
                    
                    currentRinseSteps.Index -= 1;
                    Recipe.VacuumRinseStep[SelectedVacuumPrewetIndex-1].Index += 1;
                    
                    Recipe.VacuumRinseStep.RemoveAt(SelectedVacuumPrewetIndex);
                    Recipe.VacuumRinseStep.Insert(currentIndex - 1, currentRinseSteps);
                    SelectedVacuumPrewetIndex = currentIndex - 1;
                }
            }
        }
        /// <summary>
        /// 下移
        /// </summary>
        /// <param name="param"></param>
        private void MoveDownAction(object param)
        {
            if (Recipe != null)
            {
                if (SelectedVacuumPrewetIndex >= 0 && SelectedVacuumPrewetIndex < Recipe.VacuumRinseStep.Count - 1 && Recipe.VacuumRinseStep.Count > 1)
                {
                    int currentIndex = SelectedVacuumPrewetIndex;
                    VpwRinseStep currentRinseSteps = Recipe.VacuumRinseStep[SelectedVacuumPrewetIndex];
                    
                    currentRinseSteps.Index += 1;
                    Recipe.VacuumRinseStep[SelectedVacuumPrewetIndex + 1].Index -= 1;
                    
                    Recipe.VacuumRinseStep.RemoveAt(SelectedVacuumPrewetIndex);
                    Recipe.VacuumRinseStep.Insert(currentIndex + 1, currentRinseSteps);
                    SelectedVacuumPrewetIndex = currentIndex + 1;
                }
            }
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="param"></param>
        private void DeleteAction(object param)
        {
            if (SelectedVacuumPrewetIndex != -1)
            {
                if (Recipe != null && Recipe.VacuumRinseStep.Count > SelectedVacuumPrewetIndex)
                {
                    for (int i = SelectedVacuumPrewetIndex + 1; i <= Recipe.VacuumRinseStep.Count - 1; i++)
                    {
                        Recipe.VacuumRinseStep[i].Index -= 1;
                    }
                    Recipe.VacuumRinseStep.RemoveAt(SelectedVacuumPrewetIndex);
                }
            }
        }
        #endregion

        #region Vent prewet按钮
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="param"></param>
        private void VentPrewetAddBelowAction(object param)
        {
            if (Recipe != null)
            {
                VpwRinseStep currentRinseSteps = new VpwRinseStep();

                currentRinseSteps.Index = SelectedVentPrewetIndex + 1;
                for (int i = currentRinseSteps.Index; i <= Recipe.VentRinseStep.Count - 1; i++)
                {
                    Recipe.VentRinseStep[i].Index++;
                }
                
                Recipe.VentRinseStep.Insert(SelectedVentPrewetIndex + 1, currentRinseSteps);
                SelectedVentPrewetIndex++;
            }

        }
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="param"></param>
        private void VentPrewetAddAboveAction(object param)
        {
            if (Recipe != null)
            {
                VpwRinseStep currentRinseSteps = new VpwRinseStep();
                if (SelectedVentPrewetIndex == -1)
                {
                    Recipe.VentRinseStep.Add(currentRinseSteps);
                    SelectedVentPrewetIndex = 0;
                }
                else
                {
                    currentRinseSteps.Index = SelectedVentPrewetIndex;
                    for (int i = currentRinseSteps.Index; i <= Recipe.VentRinseStep.Count - 1; i++)
                    {
                        Recipe.VentRinseStep[i].Index++;
                    }
                    
                    Recipe.VentRinseStep.Insert(SelectedVentPrewetIndex, currentRinseSteps);
                    SelectedVentPrewetIndex--;
                }
            }
        }
        /// <summary>
        /// 上移
        /// </summary>
        /// <param name="param"></param>
        private void VentPrewetMoveUpAction(object param)
        {
            if (Recipe != null)
            {
                if (SelectedVentPrewetIndex > 0)
                {
                    int currentIndex = SelectedVentPrewetIndex;
                    VpwRinseStep currentRinseSteps = Recipe.VentRinseStep[SelectedVentPrewetIndex];

                    currentRinseSteps.Index -= 1;
                    Recipe.VentRinseStep[SelectedVentPrewetIndex - 1].Index += 1;

                    Recipe.VentRinseStep.RemoveAt(SelectedVentPrewetIndex);
                    Recipe.VentRinseStep.Insert(currentIndex - 1, currentRinseSteps);
                    SelectedVentPrewetIndex = currentIndex - 1;
                }
            }
        }
        /// <summary>
        /// 下移
        /// </summary>
        /// <param name="param"></param>
        private void VentPrewetMoveDownAction(object param)
        {
            if (Recipe != null)
            {
                if (SelectedVentPrewetIndex >= 0 && SelectedVentPrewetIndex < Recipe.VentRinseStep.Count - 1 && Recipe.VentRinseStep.Count > 1)
                {
                    int currentIndex = SelectedVentPrewetIndex;
                    VpwRinseStep currentRinseSteps = Recipe.VentRinseStep[SelectedVentPrewetIndex];

                    currentRinseSteps.Index += 1;
                    Recipe.VentRinseStep[SelectedVentPrewetIndex + 1].Index -= 1;

                    Recipe.VentRinseStep.RemoveAt(SelectedVentPrewetIndex);
                    Recipe.VentRinseStep.Insert(currentIndex + 1, currentRinseSteps);
                    SelectedVentPrewetIndex = currentIndex + 1;
                }
            }
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="param"></param>
        private void VentPrewetDeleteAction(object param)
        {
            if (SelectedVentPrewetIndex != -1)
            {
                if (Recipe != null && Recipe.VentRinseStep.Count > SelectedVentPrewetIndex)
                {
                    for (int i = SelectedVentPrewetIndex + 1; i <= Recipe.VentRinseStep.Count - 1; i++)
                    {
                        Recipe.VentRinseStep[i].Index -= 1;
                    }
                    Recipe.VentRinseStep.RemoveAt(SelectedVentPrewetIndex);
                }
            }
        }
        #endregion

        #region Extend Clean按钮
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="param"></param>
        private void ExtendCleanAddBelowAction(object param)
        {
            if (Recipe != null)
            {
                VpwRinseStep currentRinseSteps = new VpwRinseStep();

                currentRinseSteps.Index = SelectedExtendCleanIndex + 1;
                for (int i = currentRinseSteps.Index; i <= Recipe.ExtendCleanRinseStep.Count - 1; i++)
                {
                    Recipe.ExtendCleanRinseStep[i].Index++;
                }

                Recipe.ExtendCleanRinseStep.Insert(SelectedExtendCleanIndex + 1, currentRinseSteps);
                SelectedExtendCleanIndex++;
            }

        }
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="param"></param>
        private void ExtendCleanAddAboveAction(object param)
        {
            if (Recipe != null)
            {
                VpwRinseStep currentRinseSteps = new VpwRinseStep();
                if (SelectedExtendCleanIndex == -1)
                {
                    Recipe.ExtendCleanRinseStep.Add(currentRinseSteps);
                    SelectedExtendCleanIndex = 0;
                }
                else
                {
                    currentRinseSteps.Index = SelectedExtendCleanIndex;
                    for (int i = currentRinseSteps.Index; i <= Recipe.ExtendCleanRinseStep.Count - 1; i++)
                    {
                        Recipe.ExtendCleanRinseStep[i].Index++;
                    }
                    Recipe.ExtendCleanRinseStep.Insert(SelectedExtendCleanIndex, currentRinseSteps);
                    SelectedExtendCleanIndex--;
                }
            }
        }
        /// <summary>
        /// 上移
        /// </summary>
        /// <param name="param"></param>
        private void ExtendCleanMoveUpAction(object param)
        {
            if (Recipe != null)
            {
                if (SelectedExtendCleanIndex > 0)
                {
                    int currentIndex = SelectedExtendCleanIndex;
                    VpwRinseStep currentRinseSteps = Recipe.ExtendCleanRinseStep[SelectedExtendCleanIndex];

                    currentRinseSteps.Index -= 1;
                    Recipe.ExtendCleanRinseStep[SelectedExtendCleanIndex - 1].Index += 1;

                    Recipe.ExtendCleanRinseStep.RemoveAt(SelectedExtendCleanIndex);
                    Recipe.ExtendCleanRinseStep.Insert(currentIndex - 1, currentRinseSteps);
                    SelectedExtendCleanIndex = currentIndex - 1;
                }
            }
        }
        /// <summary>
        /// 下移
        /// </summary>
        /// <param name="param"></param>
        private void ExtendCleanMoveDownAction(object param)
        {
            if (Recipe != null)
            {
                if (SelectedExtendCleanIndex >= 0 && SelectedExtendCleanIndex < Recipe.ExtendCleanRinseStep.Count - 1 && Recipe.ExtendCleanRinseStep.Count > 1)
                {
                    int currentIndex = SelectedExtendCleanIndex;
                    VpwRinseStep currentRinseSteps = Recipe.ExtendCleanRinseStep[SelectedExtendCleanIndex];

                    currentRinseSteps.Index += 1;
                    Recipe.ExtendCleanRinseStep[SelectedExtendCleanIndex + 1].Index -= 1;

                    Recipe.ExtendCleanRinseStep.RemoveAt(SelectedExtendCleanIndex);
                    Recipe.ExtendCleanRinseStep.Insert(currentIndex + 1, currentRinseSteps);
                    SelectedExtendCleanIndex = currentIndex + 1;
                }
            }
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="param"></param>
        private void ExtendCleanDeleteAction(object param)
        {
            if (SelectedExtendCleanIndex != -1)
            {
                if (Recipe != null && Recipe.ExtendCleanRinseStep.Count > SelectedExtendCleanIndex)
                {
                    for (int i = SelectedExtendCleanIndex + 1; i <= Recipe.ExtendCleanRinseStep.Count - 1; i++)
                    {
                        Recipe.ExtendCleanRinseStep[i].Index -= 1;
                    }
                    Recipe.ExtendCleanRinseStep.RemoveAt(SelectedExtendCleanIndex);
                }
            }
        }
        #endregion

    }
}