2195 lines
84 KiB
C#
2195 lines
84 KiB
C#
using Aitex.Core.RT.Log;
|
||
using Aitex.Core.RT.SCCore;
|
||
using Caliburn.Micro;
|
||
using Caliburn.Micro.Core;
|
||
using MECF.Framework.Common.CommonData;
|
||
using MECF.Framework.Common.DataCenter;
|
||
using MECF.Framework.UI.Client.CenterViews.Editors;
|
||
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
|
||
using MECF.Framework.UI.Client.CenterViews.Editors.Sequence;
|
||
using MECF.Framework.UI.Client.ClientBase;
|
||
using OpenSEMI.ClientBase;
|
||
using OpenSEMI.ClientBase.Command;
|
||
using RecipeEditorLib.DGExtension.CustomColumn;
|
||
using RecipeEditorLib.RecipeModel.Params;
|
||
using SicUI.Client;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Collections.ObjectModel;
|
||
using System.Linq;
|
||
using System.Windows;
|
||
using System.Windows.Controls;
|
||
using System.Windows.Input;
|
||
using System.Windows.Media;
|
||
|
||
using Aitex.Core.Util;
|
||
using MECF.Framework.Common.OperationCenter;
|
||
using MECF.Framework.UI.Client.CenterViews.Configs.Roles;
|
||
|
||
namespace SicUI.Models.RecipeEditors
|
||
{
|
||
//Recipe列名编号(名称带_的为组名)
|
||
enum RecipColNo
|
||
{
|
||
Step_Information = 0,
|
||
Step,
|
||
Name,
|
||
StepTime,
|
||
SHFlow_SHTotalFlow,
|
||
ArH2Switch,
|
||
SHTotalFlow,
|
||
CarrayGasFlow,
|
||
SHTotalFlowSplitRatio,
|
||
FlowSetMode,
|
||
Pressure_Rotation,
|
||
PressureSet,
|
||
RotationSet,
|
||
Temperature_ControlMode,
|
||
PSUControlMode,
|
||
PSUSetMode,
|
||
SCRControlMode,
|
||
SCRSetMode,
|
||
Temperature_TempSetting,
|
||
PSUInnerTempSet,
|
||
PSUMiddleTempSet,
|
||
PSUOuterTempSet,
|
||
SCRTempSet,
|
||
Temperature_HeaterOutput,
|
||
PSUInnerRatioSet,
|
||
PSUMiddleRatioSet,
|
||
PSUOuterRatioSet,
|
||
SCRUpperRatioSet,
|
||
SCRMiddleRatioSet,
|
||
SCRLowerRatioSet,
|
||
SHFlow_SiSourceSi_SourceTotalFlow,
|
||
SiSourceTotalFlow,
|
||
SHFlow_SiSource_SiH4Flow,
|
||
SiH4FlowMode,
|
||
SiH4Flow,
|
||
SHFlow_SiSource_TCSFlow,
|
||
TCSFlowMode,
|
||
TCSBubbLowFlow,
|
||
TCSBubbHighFlow,
|
||
TCSPushFlow,
|
||
TCSBubbPressure,
|
||
SHFlow_SiSource_HCLFlow,
|
||
HCLFlowMode,
|
||
HCLFlow,
|
||
SHFlow_SiSource_SiSourSplit,
|
||
SiSourceSplitRatio,
|
||
SiSourcePushPressure,
|
||
SiSourceInnerFlow,
|
||
SiSourceMiddleFlow,
|
||
SiSourceOuterFlow,
|
||
SHFlow_CSource_CSourceTotalFlow,
|
||
CSourceTotalFlow,
|
||
SHFlow_CSource_C2H4Flow,
|
||
C2H4FlowMode,
|
||
C2H4Flow,
|
||
SHFlow_CSource_CSourceSplit,
|
||
CSourceSplitRatio,
|
||
CSourcePushPressure,
|
||
CSourceInnerFlow,
|
||
CSourceMiddleFlow,
|
||
CSourceOuterFlow,
|
||
SHFlow_Dope_DopeTotalFlow,
|
||
DopeTotalFlow,
|
||
SHFlow_Dope_N2Flow,
|
||
N2FlowMode,
|
||
N2ActualFlow,
|
||
N2LowFlow,
|
||
DilutFlowForN2,
|
||
DilutedN2Flow,
|
||
N2PostDilutPressure,
|
||
N2HighFlowMode,
|
||
N2HighFlow,
|
||
SHFlow_Dope_TMAFlow,
|
||
TMAFlowMode,
|
||
TMABubbFlow,
|
||
TMAPushFlow,
|
||
TMABubbPressure,
|
||
SHFlow_Dope_DopeSplit,
|
||
DopeSplitRatio,
|
||
DopePushPressure,
|
||
DopeInnerFlow,
|
||
DopeMiddleFlow,
|
||
DopeOuterFlow,
|
||
SHFlow_SHPushFlow,
|
||
SHPushTotalFlow,
|
||
SHInnerFlow,
|
||
SHMiddleFlow,
|
||
SHOuterFlow,
|
||
InnerPushFlow,
|
||
MiddlePushFlow,
|
||
OuterPushFlow,
|
||
Purge_SHPeripheryPurge,
|
||
SHPurgeFlow,
|
||
GRPurgeMainFlow,
|
||
Purge_ChamberPeripheryPurge,
|
||
OpticPurgeMainFlow,
|
||
ChamberPurgeFlow,
|
||
RotationUpPurgeFlow,
|
||
ShutterPurgeFlow,
|
||
HeaterWFPurgeFlow,
|
||
Purge_VentFlow,
|
||
TotalVentFlow,
|
||
VentPushFlow,
|
||
VentPreExhaustPressure
|
||
}
|
||
|
||
public class ProcessTypeFileItem : NotifiableItem
|
||
{
|
||
public string ProcessType { get; set; }
|
||
public ObservableCollection<FileNode> FileListByProcessType { get; set; }
|
||
|
||
private ObservableCollection<FileNode> filterFileListByProcessType;
|
||
public ObservableCollection<FileNode> FilterFileListByProcessType
|
||
{
|
||
get
|
||
{
|
||
return filterFileListByProcessType;
|
||
}
|
||
set
|
||
{
|
||
filterFileListByProcessType = value;
|
||
InvokePropertyChanged("FilterFileListByProcessType");
|
||
}
|
||
}
|
||
|
||
public ProcessTypeFileItem()
|
||
{
|
||
FileListByProcessType = new ObservableCollection<FileNode>();
|
||
FilterFileListByProcessType = new ObservableCollection<FileNode>();
|
||
}
|
||
}
|
||
|
||
public class ChamberTypeItem : NotifiableItem
|
||
{
|
||
public string ChamberType { get; set; }
|
||
public ObservableCollection<ProcessTypeFileItem> FileListByChamberType { get; set; }
|
||
|
||
public ChamberTypeItem()
|
||
{
|
||
FileListByChamberType = new ObservableCollection<ProcessTypeFileItem>();
|
||
}
|
||
}
|
||
|
||
public class RecipeEditorViewModel : UiViewModelBase //BaseModel
|
||
{
|
||
public enum FlowMode
|
||
{
|
||
Purge,
|
||
Vent,
|
||
Run,
|
||
Close,
|
||
}
|
||
|
||
public bool IsPermission { get => this.Permission == 3; }//&& RtStatus != "AutoRunning";
|
||
|
||
private ICommand _RenameFolderCommand;
|
||
public ICommand RenameFolderCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._RenameFolderCommand == null)
|
||
this._RenameFolderCommand = new BaseCommand(() => this.RenameFolder());
|
||
return this._RenameFolderCommand;
|
||
}
|
||
}
|
||
|
||
private ICommand _DeleteFolderCommand;
|
||
public ICommand DeleteFolderCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._DeleteFolderCommand == null)
|
||
this._DeleteFolderCommand = new BaseCommand(() => this.DeleteFolder());
|
||
return this._DeleteFolderCommand;
|
||
}
|
||
}
|
||
|
||
private ICommand _NewFolderCommand;
|
||
public ICommand NewFolderCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._NewFolderCommand == null)
|
||
this._NewFolderCommand = new BaseCommand(() => this.NewFolder());
|
||
return this._NewFolderCommand;
|
||
}
|
||
}
|
||
private ICommand _NewFolderRootCommand;
|
||
public ICommand NewFolderRootCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._NewFolderRootCommand == null)
|
||
this._NewFolderRootCommand = new BaseCommand(() => this.NewFolderRoot());
|
||
return this._NewFolderRootCommand;
|
||
}
|
||
}
|
||
|
||
private ICommand _NewRecipeCommand;
|
||
public ICommand NewRecipeCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._NewRecipeCommand == null)
|
||
this._NewRecipeCommand = new BaseCommand(() => this.NewRecipe());
|
||
return this._NewRecipeCommand;
|
||
}
|
||
}
|
||
|
||
private ICommand _NewRecipeRootCommand;
|
||
public ICommand NewRecipeRootCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._NewRecipeRootCommand == null)
|
||
this._NewRecipeRootCommand = new BaseCommand(() => this.NewRecipeRoot());
|
||
return this._NewRecipeRootCommand;
|
||
}
|
||
}
|
||
private ICommand _RenameRecipeCommand;
|
||
public ICommand RenameRecipeCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._RenameRecipeCommand == null)
|
||
this._RenameRecipeCommand = new BaseCommand(() => this.RenameRecipe());
|
||
return this._RenameRecipeCommand;
|
||
}
|
||
}
|
||
private ICommand _DeleteRecipeCommand;
|
||
public ICommand DeleteRecipeCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._DeleteRecipeCommand == null)
|
||
this._DeleteRecipeCommand = new BaseCommand(() => this.DeleteRecipe());
|
||
return this._DeleteRecipeCommand;
|
||
}
|
||
}
|
||
|
||
private ICommand _SaveAsRecipeCommand;
|
||
public ICommand SaveAsRecipeCommand
|
||
{
|
||
get
|
||
{
|
||
if (this._SaveAsRecipeCommand == null)
|
||
this._SaveAsRecipeCommand = new BaseCommand(() => this.SaveAsRecipe());
|
||
return this._SaveAsRecipeCommand;
|
||
}
|
||
}
|
||
|
||
|
||
private ObservableCollection<ProcessTypeFileItem> processTypeFileList;
|
||
public ObservableCollection<ProcessTypeFileItem> ProcessTypeFileList
|
||
{
|
||
get
|
||
{
|
||
return processTypeFileList;
|
||
}
|
||
set
|
||
{
|
||
processTypeFileList = value;
|
||
NotifyOfPropertyChange("ProcessTypeFileList");
|
||
}
|
||
}
|
||
|
||
public RecipeData currentRecipe;
|
||
public RecipeData CurrentRecipe
|
||
{
|
||
get
|
||
{
|
||
return currentRecipe;
|
||
}
|
||
set
|
||
{
|
||
currentRecipe = value;
|
||
NotifyOfPropertyChange("CurrentRecipe");
|
||
}
|
||
}
|
||
|
||
public FileNode CurrentFileNode { get; set; }
|
||
|
||
private bool IsChanged
|
||
{
|
||
get
|
||
{
|
||
return editMode == EditMode.Edit || CurrentRecipe.IsChanged;
|
||
}
|
||
}
|
||
|
||
public ObservableCollection<EditorDataGridTemplateColumnBase> Columns { get; set; }
|
||
|
||
public Dictionary<string, ObservableCollection<EditorDataGridTemplateColumnBase>> DicColunms { get; set; }
|
||
|
||
public bool EnableNew { get; set; }
|
||
public bool EnableReName { get; set; }
|
||
public bool EnableCopy { get; set; }
|
||
public bool EnableDelete { get; set; }
|
||
public bool EnableSave { get; set; }
|
||
public bool EnableStep { get; set; }
|
||
|
||
public bool EnableReload { get =>IsPermission; }
|
||
|
||
public bool EnableSaveToAll { get; set; }
|
||
public bool EnableSaveTo { get; set; }
|
||
|
||
|
||
private RecipeFormatBuilder _columnBuilder = new RecipeFormatBuilder();
|
||
|
||
private EditMode editMode;
|
||
|
||
private RecipeProvider _recipeProvider = new RecipeProvider();
|
||
|
||
public ObservableCollection<string> ChamberType { get; set; }
|
||
|
||
public int ChamberTypeIndexSelection { get; set; }
|
||
|
||
public int ProcessTypeIndexSelection { get; set; }
|
||
|
||
public string CurrentChamberType
|
||
{
|
||
get
|
||
{
|
||
return ChamberType[ChamberTypeIndexSelection];
|
||
}
|
||
}
|
||
|
||
public string CurrentProcessType
|
||
{
|
||
get
|
||
{
|
||
return ProcessTypeFileList[ProcessTypeIndexSelection].ProcessType;
|
||
}
|
||
}
|
||
|
||
public Visibility MultiChamberVisibility
|
||
{
|
||
get;
|
||
set;
|
||
}
|
||
|
||
public ObservableCollection<string> Chambers { get; set; }
|
||
|
||
public string SelectedChamber { get; set; }
|
||
|
||
public object View { get; set; }
|
||
|
||
private bool isRunPrugeSwitch;
|
||
private bool isTMANotInstall;
|
||
private bool isHClNotInstall;
|
||
private bool isHClFlowNotInstall;
|
||
|
||
#region Password check
|
||
private bool _editorEnabled = false;
|
||
public bool EditorEnable
|
||
{
|
||
get { return _editorEnabled; }
|
||
set { _editorEnabled = value; }
|
||
}
|
||
public Visibility EditorEnableV
|
||
{
|
||
get
|
||
{
|
||
return EditorEnable ? Visibility.Visible : Visibility.Hidden;
|
||
}
|
||
}
|
||
private string _loginText = "Log In";
|
||
public string LoginText
|
||
{
|
||
get { return _loginText; }
|
||
set { LoginText = value; }
|
||
}
|
||
[Subscription("PM1.Recipe.EditPassword")]
|
||
public string EPassword { get; set; }
|
||
|
||
public void ChangePassword()
|
||
{
|
||
var pcg = new EditorPassChangeView(this);
|
||
pcg.Password = EPassword;
|
||
|
||
var bRes = pcg.ShowDialog();
|
||
}
|
||
public bool ChanagePasswordReal(string sNewPassword)
|
||
{
|
||
try
|
||
{
|
||
//EPassword = sNewPassword;
|
||
InvokeClient.Instance.Service.DoOperation("PM1.Recipe.EditorChangePassword", sNewPassword);
|
||
System.Threading.Thread.Sleep(1000);
|
||
|
||
return (sNewPassword == EPassword);
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
//return true;
|
||
}
|
||
public void EditLogin()
|
||
{
|
||
|
||
if (EditorEnable)
|
||
{
|
||
EditorEnable = false;
|
||
_loginText = "Log In";
|
||
}
|
||
else
|
||
{
|
||
EditorEnable = PasswordCheck();
|
||
if (EditorEnable)
|
||
{
|
||
_loginText = "Log out";
|
||
|
||
}
|
||
}
|
||
//已更换继承的父类,这里不再使用Notify
|
||
//NotifyOfPropertyChange("LoginText");
|
||
//NotifyOfPropertyChange("EditorEnable");
|
||
|
||
|
||
}
|
||
private bool PasswordCheck()
|
||
{
|
||
var pc = new EditorPassCheckView(this);
|
||
pc.Password = EPassword;
|
||
|
||
if (pc.Password == "0")
|
||
{
|
||
MessageBox.Show("First time to use. Please click ChgPass button to Change Password.");
|
||
return false;
|
||
}
|
||
|
||
var bRes = pc.ShowDialog();
|
||
//
|
||
if (bRes == true)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
//
|
||
return false;
|
||
}
|
||
|
||
//
|
||
#endregion
|
||
|
||
protected override void OnInitialize()
|
||
{
|
||
base.OnInitialize();
|
||
|
||
var chamberType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedChamberType");
|
||
if (chamberType == null)
|
||
{
|
||
ChamberType = new ObservableCollection<string>() { "Default" };
|
||
}
|
||
else
|
||
{
|
||
ChamberType = new ObservableCollection<string>(((string)(chamberType)).Split(','));
|
||
}
|
||
|
||
ChamberTypeIndexSelection = 0;
|
||
|
||
var processType = "Process,Routine,Clean";
|
||
|
||
ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
|
||
var recipeProcessType = ((string)processType).Split(',');
|
||
|
||
for (var i = 0; i < recipeProcessType.Length; i++)
|
||
{
|
||
var type = new ProcessTypeFileItem();
|
||
type.ProcessType = recipeProcessType[i];
|
||
var prefix = $"{ChamberType[ChamberTypeIndexSelection]}\\{recipeProcessType[i]}";
|
||
var recipes = _recipeProvider.GetXmlRecipeList(prefix);
|
||
type.FileListByProcessType = RecipeSequenceTreeBuilder.BuildFileNode(prefix, "", false, recipes)[0].Files;
|
||
type.FilterFileListByProcessType = type.FileListByProcessType;
|
||
ProcessTypeFileList.Add(type);
|
||
}
|
||
|
||
DicColunms = new Dictionary<string, ObservableCollection<EditorDataGridTemplateColumnBase>>();
|
||
UpdateRecipeFormat();
|
||
}
|
||
|
||
protected override void OnActivate()
|
||
{
|
||
|
||
//初始化RoleManager
|
||
var roleManager = new RoleManager();
|
||
roleManager.Initialize();
|
||
|
||
//得到当前登录的RoleItem
|
||
var roleItem = roleManager.GetRoleByName(ClientApp.Instance.UserContext.RoleName);
|
||
var menuPermission = new MenuPermission();
|
||
menuPermission.ParsePermission(roleItem.Role.MenuPermission);
|
||
|
||
foreach (var col in Columns)
|
||
{
|
||
if (menuPermission.MenuPermissionDictionary.ContainsKey(col.DisplayName.Replace(" ", "")) &&
|
||
menuPermission.MenuPermissionDictionary[col.DisplayName.Replace(" ", "")] ==
|
||
MenuPermissionEnum.MP_NONE)
|
||
{
|
||
col.Visibility = Visibility.Hidden;
|
||
}
|
||
|
||
if (col.ControlName == "StepNo")
|
||
continue;
|
||
|
||
|
||
if (CurrentProcessType.EndsWith("Process") &&
|
||
menuPermission.MenuPermissionDictionary.ContainsKey(col.DisplayName.Replace(" ", "")))
|
||
{
|
||
RecipeFormatBuilder.SetCellEnable(col,
|
||
menuPermission.MenuPermissionDictionary[col.DisplayName.Replace(" ", "")]);
|
||
}
|
||
}
|
||
|
||
//this.Columns = this._columnBuilder.Build($"{CurrentChamberType}\\{CurrentProcessType}", SelectedChamber, true, ClientApp.Instance.UserContext.RoleName);
|
||
|
||
base.OnActivate();
|
||
}
|
||
|
||
protected override void OnDeactivate(bool close)
|
||
{
|
||
base.OnDeactivate(close);
|
||
|
||
if (this.IsChanged)
|
||
{
|
||
if (DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM, $"Recipe {CurrentRecipe.Name} content is changed, do you want to save it?") == DialogButton.Yes)
|
||
{
|
||
this.SaveRecipe();
|
||
}
|
||
}
|
||
}
|
||
|
||
protected override void OnViewLoaded(object view)
|
||
{
|
||
View = view;
|
||
base.OnViewLoaded(view);
|
||
RecipeFormatBuilder.ApplyTemplate((UserControl)view, this.Columns);
|
||
var u = (RecipeEditorView)view;
|
||
u.dgCustom.Columns.Clear();
|
||
|
||
this.Columns.Apply((c) =>
|
||
{
|
||
c.Header = c;
|
||
u.dgCustom.Columns.Add(c);
|
||
|
||
});
|
||
|
||
u.dgCustom.ItemsSource = this.CurrentRecipe.Steps;
|
||
|
||
u.dgCustom.LostFocus += DgCustom_LostFocus;
|
||
|
||
u.dgCustom.FrozenColumnCount = 4;
|
||
}
|
||
|
||
private void LostFocusFunc()
|
||
{
|
||
isRunPrugeSwitch = false;
|
||
isTMANotInstall = false;
|
||
isHClNotInstall = false;
|
||
isHClFlowNotInstall = false;
|
||
|
||
CurrentRecipe.RecipeTotalTime = 0;
|
||
|
||
for (var selectIndex = 0; selectIndex < this.CurrentRecipe.Steps.Count; selectIndex++)
|
||
{
|
||
var previousIndex = selectIndex == 0 ? 0 : selectIndex - 1;
|
||
var currentIndex = selectIndex;
|
||
var nextIndex = selectIndex == this.CurrentRecipe.Steps.Count - 1 ? selectIndex : selectIndex + 1;
|
||
|
||
var previousStep = this.CurrentRecipe.Steps[previousIndex];
|
||
var currentStep = this.CurrentRecipe.Steps[currentIndex];
|
||
var nextStep = this.CurrentRecipe.Steps[nextIndex];
|
||
|
||
//判断每步与上一步值是否相同，不同则以颜色区分
|
||
JudgeStepSameValue(previousStep, currentStep);
|
||
|
||
//如果是Routine则在下面代码不执行，在这里continue
|
||
if (CurrentProcessType == ProcessTypeFileList[1].ProcessType)
|
||
{
|
||
//如果是Routine,则总时间需*循环次数
|
||
var loopTimes = int.Parse((currentStep[8] as DoubleParam).Value) == 0 ? 1 : int.Parse((currentStep[8] as DoubleParam).Value);
|
||
CurrentRecipe.RecipeTotalTime += int.Parse((currentStep[(int)RecipColNo.StepTime] as DoubleParam).Value) * loopTimes;
|
||
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
//如果是Recipe则总时间直接加
|
||
CurrentRecipe.RecipeTotalTime += int.Parse((currentStep[(int)RecipColNo.StepTime] as DoubleParam).Value);
|
||
}
|
||
|
||
double.TryParse((currentStep[(int)RecipColNo.StepTime] as DoubleParam).Value, out var stepTime);
|
||
|
||
PurgeRunSwitch(previousStep, currentStep, nextStep);
|
||
|
||
NotIntallDevice(currentStep);
|
||
|
||
if (stepTime > 0)
|
||
{
|
||
CalRecipeParameterForRunVent(previousStep, currentStep, stepTime);
|
||
}
|
||
}
|
||
|
||
//如果是Routine则在下面代码不执行，在这里返回
|
||
if (CurrentProcessType == ProcessTypeFileList[1].ProcessType)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (isRunPrugeSwitch)
|
||
MessageBox.Show("Flow mode 'Run' and 'Purge' can't switch directly", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning);
|
||
|
||
if (isTMANotInstall)
|
||
MessageBox.Show("TMA is not install, only Purge mode is valid", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning);
|
||
|
||
if (isHClNotInstall)
|
||
MessageBox.Show("GR Purge HCl is not install, only Disable is valid", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning);
|
||
|
||
if (isHClFlowNotInstall)
|
||
MessageBox.Show("GR Purge HCl Flow is not install, lock the value as zero", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning);
|
||
}
|
||
|
||
private void DgCustom_LostFocus(object sender, RoutedEventArgs e)
|
||
{
|
||
LostFocusFunc();
|
||
}
|
||
|
||
private void JudgeStepSameValue(ObservableCollection<Param> previousStep, ObservableCollection<Param> currentStep)
|
||
{
|
||
for (var i = 0; i < currentStep.Count; i++)
|
||
{
|
||
if(currentStep[i].GetType() == typeof(DoubleParam))
|
||
{
|
||
if ((previousStep[i] as DoubleParam).Value != (currentStep[i] as DoubleParam).Value)
|
||
{
|
||
(currentStep[i] as DoubleParam).Foreground = "Green";
|
||
}
|
||
else
|
||
{
|
||
(currentStep[i] as DoubleParam).Foreground = "Black";
|
||
}
|
||
}
|
||
|
||
if (currentStep[i].GetType() == typeof(ComboxParam))
|
||
{
|
||
if ((previousStep[i] as ComboxParam).Value != (currentStep[i] as ComboxParam).Value)
|
||
{
|
||
(currentStep[i] as ComboxParam).Foreground = "Green";
|
||
}
|
||
else
|
||
{
|
||
(currentStep[i] as ComboxParam).Foreground = "Black";
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
private void PurgeRunSwitch(ObservableCollection<Param> previousStep, ObservableCollection<Param> currentStep,
|
||
ObservableCollection<Param> nextStep)
|
||
{
|
||
var previousSiH4FlowMode = previousStep[(int)RecipColNo.SiH4FlowMode] as ComboxParam;
|
||
var previousTCSFlowMode = previousStep[(int)RecipColNo.TCSFlowMode] as ComboxParam;
|
||
var previousHClFlowMode = previousStep[(int)RecipColNo.HCLFlowMode] as ComboxParam;
|
||
var previousC2H4FlowMode = previousStep[(int)RecipColNo.C2H4FlowMode] as ComboxParam;
|
||
var previousN2FlowMode = previousStep[(int)RecipColNo.N2FlowMode] as ComboxParam;
|
||
var previousN2HighFlowMode = previousStep[(int)RecipColNo.N2HighFlowMode] as ComboxParam;
|
||
var previousTMAFlowMode = previousStep[(int)RecipColNo.TMAFlowMode] as ComboxParam;
|
||
|
||
var currentSiH4FlowMode = currentStep[(int)RecipColNo.SiH4FlowMode] as ComboxParam;
|
||
var currentTCSFlowMode = currentStep[(int)RecipColNo.TCSFlowMode] as ComboxParam;
|
||
var currentHClFlowMode = currentStep[(int)RecipColNo.HCLFlowMode] as ComboxParam;
|
||
var currentC2H4FlowMode = currentStep[(int)RecipColNo.C2H4FlowMode] as ComboxParam;
|
||
var currentN2FlowMode = currentStep[(int)RecipColNo.N2FlowMode] as ComboxParam;
|
||
var currentN2HighFlowMode = currentStep[(int)RecipColNo.N2HighFlowMode] as ComboxParam;
|
||
var currentTMAFlowMode = currentStep[(int)RecipColNo.TMAFlowMode] as ComboxParam;
|
||
|
||
var nextSiH4FlowMode = nextStep[(int)RecipColNo.SiH4FlowMode] as ComboxParam;
|
||
var nextTCSFlowMode = nextStep[(int)RecipColNo.TCSFlowMode] as ComboxParam;
|
||
var nextHClFlowMode = nextStep[(int)RecipColNo.HCLFlowMode] as ComboxParam;
|
||
var nextC2H4FlowMode = nextStep[(int)RecipColNo.C2H4FlowMode] as ComboxParam;
|
||
var nextN2FlowMode = nextStep[(int)RecipColNo.N2FlowMode] as ComboxParam;
|
||
var nextN2HighFlowMode = nextStep[(int)RecipColNo.N2HighFlowMode] as ComboxParam;
|
||
var nextTMAFlowMode = nextStep[(int)RecipColNo.TMAFlowMode] as ComboxParam;
|
||
|
||
var previousFlowMode = new List<ComboxParam>() { previousSiH4FlowMode, previousTCSFlowMode, previousHClFlowMode,
|
||
previousC2H4FlowMode, previousN2FlowMode,previousN2FlowMode, previousN2HighFlowMode, previousTMAFlowMode};
|
||
|
||
var currentFlowMode = new List<ComboxParam>() { currentSiH4FlowMode, currentTCSFlowMode, currentHClFlowMode,
|
||
currentC2H4FlowMode, currentN2FlowMode,currentN2FlowMode, currentN2HighFlowMode, currentTMAFlowMode};
|
||
|
||
var nextFlowMode = new List<ComboxParam>() { nextSiH4FlowMode, nextTCSFlowMode, nextHClFlowMode,
|
||
nextC2H4FlowMode, nextN2FlowMode,nextN2FlowMode, nextN2HighFlowMode, nextTMAFlowMode};
|
||
|
||
for (var i = 0; i < currentFlowMode.Count; i++)
|
||
{
|
||
if (previousFlowMode[i].Value == FlowMode.Run.ToString() && currentFlowMode[i].Value == FlowMode.Purge.ToString()
|
||
|| previousFlowMode[i].Value == FlowMode.Purge.ToString() && currentFlowMode[i].Value == FlowMode.Run.ToString())
|
||
{
|
||
isRunPrugeSwitch = true;
|
||
currentFlowMode[i].Value = FlowMode.Vent.ToString();
|
||
}
|
||
|
||
if (nextFlowMode[i].Value == FlowMode.Run.ToString() && currentFlowMode[i].Value == FlowMode.Purge.ToString()
|
||
|| nextFlowMode[i].Value == FlowMode.Purge.ToString() && currentFlowMode[i].Value == FlowMode.Run.ToString())
|
||
{
|
||
isRunPrugeSwitch = true;
|
||
currentFlowMode[i].Value = FlowMode.Vent.ToString();
|
||
}
|
||
}
|
||
}
|
||
|
||
private void NotIntallDevice(ObservableCollection<Param> currentStep)
|
||
{
|
||
var currentTMAFlowMode = currentStep[(int)RecipColNo.TMAFlowMode] as ComboxParam;
|
||
//var currentGRPurgeHCl = currentStep[(int)RecipColNo.HeaterUpPurgeHCL] as ComboxParam;
|
||
//var currentGRPurgeHClFlow = currentStep[(int)RecipColNo.GRPurgeHCLFlow] as DoubleParam;
|
||
|
||
if (currentTMAFlowMode.Value != FlowMode.Purge.ToString())
|
||
{
|
||
currentTMAFlowMode.Value = FlowMode.Purge.ToString();
|
||
isTMANotInstall = true;
|
||
}
|
||
|
||
//if (currentGRPurgeHCl.Value != "Disable")
|
||
//{
|
||
// currentGRPurgeHCl.Value = "Disable";
|
||
// isHClNotInstall = true;
|
||
//}
|
||
|
||
//if(currentGRPurgeHClFlow != null)
|
||
//{
|
||
// double.TryParse(currentGRPurgeHClFlow.Value, out double value);
|
||
|
||
// if (value != 0)
|
||
// {
|
||
// currentGRPurgeHClFlow.Value = "0";
|
||
// isHClFlowNotInstall = true;
|
||
// }
|
||
//}
|
||
}
|
||
|
||
private void CalRecipeParameterForRunVent(ObservableCollection<Param> previousStep, ObservableCollection<Param> currentStep, double stepTime)
|
||
{
|
||
#region SH Total flow
|
||
|
||
double.TryParse((currentStep[(int)RecipColNo.SHTotalFlow] as DoubleParam).Value, out var currentSHTotalFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.CarrayGasFlow] as DoubleParam).Value, out var currentSurroundingFlow);
|
||
|
||
var arrSHTotalFlowSplitRatio = (currentStep[(int)RecipColNo.SHTotalFlowSplitRatio] as StringParam).Value.Split(':');
|
||
var currentSHTotalFlowSplitRatio = new double[3];
|
||
if (arrSHTotalFlowSplitRatio.Length == 3)
|
||
{
|
||
double.TryParse(arrSHTotalFlowSplitRatio[0], out currentSHTotalFlowSplitRatio[0]);
|
||
double.TryParse(arrSHTotalFlowSplitRatio[1], out currentSHTotalFlowSplitRatio[1]);
|
||
double.TryParse(arrSHTotalFlowSplitRatio[2], out currentSHTotalFlowSplitRatio[2]);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Si Source
|
||
|
||
double.TryParse((currentStep[(int)RecipColNo.SiH4Flow] as DoubleParam).Value, out var currentSiH4Flow);
|
||
double.TryParse((currentStep[(int)RecipColNo.TCSBubbLowFlow] as DoubleParam).Value, out var currentTCSBubbLowFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.TCSBubbHighFlow] as DoubleParam).Value, out var currentTCSBubbHighFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.TCSPushFlow] as DoubleParam).Value, out var currentTCSPushFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.HCLFlow] as DoubleParam).Value, out var currentHClFlow);
|
||
|
||
var arrSiSourSplitRatio = (currentStep[(int)RecipColNo.SiSourceSplitRatio] as StringParam).Value.Split(':');
|
||
var currentSiSourSplitRatio = new double[3];
|
||
if (arrSiSourSplitRatio.Length == 3)
|
||
{
|
||
double.TryParse(arrSiSourSplitRatio[0], out currentSiSourSplitRatio[0]);
|
||
double.TryParse(arrSiSourSplitRatio[1], out currentSiSourSplitRatio[1]);
|
||
double.TryParse(arrSiSourSplitRatio[2], out currentSiSourSplitRatio[2]);
|
||
}
|
||
|
||
double.TryParse((currentStep[(int)RecipColNo.SiSourceTotalFlow] as DoubleParam).Value, out var currentSiSourTotalFlow);
|
||
|
||
var currentSiH4FlowMode = (currentStep[(int)RecipColNo.SiH4FlowMode] as ComboxParam).Value;
|
||
var currentTCSFlowMode = (currentStep[(int)RecipColNo.TCSFlowMode] as ComboxParam).Value;
|
||
var currentHClFlowMode = (currentStep[(int)RecipColNo.HCLFlowMode] as ComboxParam).Value;
|
||
|
||
double TCSFlow = 0;
|
||
var TCS_Eff = (double)QueryDataClient.Instance.Service.GetConfig($"PM.{SelectedChamber}.Efficiency.TCS-Eff");
|
||
if (currentTCSFlowMode == FlowMode.Run.ToString() || currentTCSFlowMode == FlowMode.Vent.ToString())
|
||
TCSFlow = (currentTCSBubbHighFlow + currentTCSBubbLowFlow) * TCS_Eff + currentTCSPushFlow;
|
||
else if (currentTCSFlowMode == FlowMode.Purge.ToString())
|
||
TCSFlow = currentTCSBubbHighFlow + currentTCSBubbLowFlow + currentTCSPushFlow;
|
||
|
||
//double currentSiSourPushFlow = currentSiSourTotalFlow - (currentSiH4FlowMode == FlowMode.Run.ToString() ? currentSiH4Flow : 0)
|
||
// - (currentTCSFlowMode == FlowMode.Run.ToString() ? TCSFlow : 0) - (currentHClFlowMode == FlowMode.Run.ToString() ? currentHClFlow : 0);
|
||
|
||
//(currentStep[(int)RecipColNo.SiSourceOuterFlow] as DoubleParam).Value = currentSiSourPushFlow.ToString("F1");
|
||
|
||
double currentSiSourInnerFlow = 0;
|
||
double currentSiSourMidFlow = 0;
|
||
double currentSiSourOutFlow = 0;
|
||
|
||
if (currentSiSourSplitRatio.Length == 3)
|
||
{
|
||
var rationSum = currentSiSourSplitRatio[0] + currentSiSourSplitRatio[1] + currentSiSourSplitRatio[2];
|
||
|
||
currentSiSourInnerFlow = currentSiSourTotalFlow / rationSum * currentSiSourSplitRatio[0];
|
||
currentSiSourMidFlow = currentSiSourTotalFlow / rationSum * currentSiSourSplitRatio[1];
|
||
currentSiSourOutFlow = currentSiSourTotalFlow / rationSum * currentSiSourSplitRatio[2];
|
||
}
|
||
|
||
(currentStep[(int)RecipColNo.SiSourceInnerFlow] as DoubleParam).Value = currentSiSourInnerFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.SiSourceMiddleFlow] as DoubleParam).Value = currentSiSourMidFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.SiSourceOuterFlow] as DoubleParam).Value = currentSiSourOutFlow.ToString("F1");
|
||
|
||
#endregion
|
||
|
||
#region C Source
|
||
|
||
double.TryParse((currentStep[(int)RecipColNo.C2H4Flow] as DoubleParam).Value, out var currentC2H4Flow);
|
||
|
||
var arrCSourSplitRatio = (currentStep[(int)RecipColNo.CSourceSplitRatio] as StringParam).Value.Split(':');
|
||
var currentCSourSplitRatio = new double[3];
|
||
if (arrCSourSplitRatio.Length == 3)
|
||
{
|
||
double.TryParse(arrCSourSplitRatio[0], out currentCSourSplitRatio[0]);
|
||
double.TryParse(arrCSourSplitRatio[1], out currentCSourSplitRatio[1]);
|
||
double.TryParse(arrCSourSplitRatio[2], out currentCSourSplitRatio[2]);
|
||
}
|
||
|
||
double.TryParse((currentStep[(int)RecipColNo.CSourceTotalFlow] as DoubleParam).Value, out var currentCSourTotalFlow);
|
||
|
||
var currentC2H4FlowMode = (currentStep[(int)RecipColNo.C2H4FlowMode] as ComboxParam).Value;
|
||
var currentCSourPushFlow = currentCSourTotalFlow - (currentC2H4FlowMode == FlowMode.Run.ToString() ? currentC2H4Flow : 0);
|
||
|
||
(currentStep[(int)RecipColNo.CSourceOuterFlow] as DoubleParam).Value = currentCSourPushFlow.ToString("F1");
|
||
|
||
double currentCSourInnerFlow = 0;
|
||
double currentCSourMidFlow = 0;
|
||
double currentCSourOuterFlow = 0;
|
||
|
||
if (currentCSourSplitRatio.Length == 3)
|
||
{
|
||
var ratioSum = currentCSourSplitRatio[0] + currentCSourSplitRatio[1] + currentCSourSplitRatio[2];
|
||
|
||
currentCSourInnerFlow = currentCSourTotalFlow / ratioSum * currentCSourSplitRatio[0];
|
||
currentCSourMidFlow = currentCSourTotalFlow / ratioSum * currentCSourSplitRatio[1];
|
||
currentCSourOuterFlow= currentCSourTotalFlow / ratioSum * currentCSourSplitRatio[2];
|
||
}
|
||
|
||
(currentStep[(int)RecipColNo.CSourceInnerFlow] as DoubleParam).Value = currentCSourInnerFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.CSourceMiddleFlow] as DoubleParam).Value = currentCSourMidFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.CSourceOuterFlow] as DoubleParam).Value = currentCSourOuterFlow.ToString("F1");
|
||
|
||
#endregion
|
||
|
||
#region Dope
|
||
double.TryParse((currentStep[(int)RecipColNo.DopeTotalFlow] as DoubleParam).Value, out var currentDopeTotalFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.N2ActualFlow] as DoubleParam).Value, out var currentN2ActualFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.N2LowFlow] as DoubleParam).Value, out var currentN2LowFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.DilutFlowForN2] as DoubleParam).Value, out var currentDiluFlowForN2);
|
||
|
||
double.TryParse((currentStep[(int)RecipColNo.N2HighFlow] as DoubleParam).Value, out var currentN2HighFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.TMABubbFlow] as DoubleParam).Value, out var currentTMABubbFlow);
|
||
double.TryParse((currentStep[(int)RecipColNo.TMAPushFlow] as DoubleParam).Value, out var currentTMAPushFlow);
|
||
|
||
var currentDilutedN2Flow = (currentN2LowFlow + currentDiluFlowForN2) * currentN2ActualFlow / currentN2LowFlow;
|
||
(currentStep[(int)RecipColNo.DilutedN2Flow] as DoubleParam).Value = currentDilutedN2Flow.ToString("F1");
|
||
|
||
var arrDopeSplitRatio = (currentStep[(int)RecipColNo.DopeSplitRatio] as StringParam).Value.Split(':');
|
||
var currentDopeSplitRatio = new double[3];
|
||
if (arrDopeSplitRatio.Length == 3)
|
||
{
|
||
double.TryParse(arrDopeSplitRatio[0], out currentDopeSplitRatio[0]);
|
||
double.TryParse(arrDopeSplitRatio[1], out currentDopeSplitRatio[1]);
|
||
double.TryParse(arrDopeSplitRatio[2], out currentDopeSplitRatio[2]);
|
||
}
|
||
|
||
var currentN2FlowMode = (currentStep[(int)RecipColNo.N2FlowMode] as ComboxParam).Value;
|
||
var currentN2HighFlowMode = (currentStep[(int)RecipColNo.N2HighFlowMode] as ComboxParam).Value;
|
||
var currentTMAFlowMode = (currentStep[(int)RecipColNo.TMAFlowMode] as ComboxParam).Value;
|
||
|
||
double TMAFlow = 0;
|
||
var TMA_Eff = (double)QueryDataClient.Instance.Service.GetConfig($"PM.{SelectedChamber}.Efficiency.TMA-Eff");
|
||
if (currentTMAFlowMode == FlowMode.Run.ToString() || currentTMAFlowMode == FlowMode.Vent.ToString())
|
||
TMAFlow = currentTMABubbFlow * TMA_Eff + currentTMAPushFlow;
|
||
else if (currentTMAFlowMode == FlowMode.Purge.ToString())
|
||
TMAFlow = currentTMABubbFlow + currentTMAPushFlow;
|
||
|
||
//double currentDopePushFlow = currentDopeTotalFlow
|
||
// - (currentN2FlowMode == FlowMode.Run.ToString() ? currentDilutedN2Flow : 0)
|
||
// - (currentN2HighFlowMode == FlowMode.Run.ToString() ? currentN2HighFlow : 0)
|
||
// - (currentTMAFlowMode == FlowMode.Run.ToString() ? TMAFlow : 0);
|
||
|
||
//(currentStep[(int)RecipColNo.DopeOuterFlow] as DoubleParam).Value = currentDopePushFlow.ToString("F1");
|
||
|
||
double currentDopeInnerFlow = 0;
|
||
double currentDopeMidFlow = 0;
|
||
double currentDopeOuterFlow = 0;
|
||
|
||
if (currentDopeSplitRatio.Length == 3)
|
||
{
|
||
var ratioSum = currentDopeSplitRatio[0] + currentDopeSplitRatio[1] + currentDopeSplitRatio[2];
|
||
|
||
currentDopeInnerFlow = currentDopeTotalFlow / ratioSum * currentDopeSplitRatio[0];
|
||
currentDopeMidFlow = currentDopeTotalFlow / ratioSum * currentDopeSplitRatio[1];
|
||
currentDopeOuterFlow = currentDopeTotalFlow / ratioSum * currentDopeSplitRatio[2];
|
||
}
|
||
|
||
(currentStep[(int)RecipColNo.DopeInnerFlow] as DoubleParam).Value = currentDopeInnerFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.DopeMiddleFlow] as DoubleParam).Value = currentDopeMidFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.DopeOuterFlow] as DoubleParam).Value = currentDopeOuterFlow.ToString("F1");
|
||
|
||
#endregion
|
||
|
||
#region SH Supp. Flow
|
||
|
||
var currentSHSuppTotalFlow = currentSHTotalFlow - currentSurroundingFlow - currentSiSourTotalFlow - currentCSourTotalFlow - currentDopeTotalFlow;
|
||
var sumSHTotalFlowSplitRatio = currentSHTotalFlowSplitRatio[0] + currentSHTotalFlowSplitRatio[1] + currentSHTotalFlowSplitRatio[2];
|
||
var currentSHInnerFlow = (currentSHTotalFlow - currentSurroundingFlow) / sumSHTotalFlowSplitRatio * currentSHTotalFlowSplitRatio[0];
|
||
var currentSHMidFlow = (currentSHTotalFlow - currentSurroundingFlow) / sumSHTotalFlowSplitRatio * currentSHTotalFlowSplitRatio[1];
|
||
var currentSHOutterFlow = (currentSHTotalFlow - currentSurroundingFlow) / sumSHTotalFlowSplitRatio * currentSHTotalFlowSplitRatio[2];
|
||
var currentInnerSuppFlow = currentSHInnerFlow - currentSiSourInnerFlow - currentCSourInnerFlow - currentDopeInnerFlow;
|
||
var currentMidSuppFlow = currentSHMidFlow - currentSiSourMidFlow - currentCSourMidFlow - currentDopeMidFlow;
|
||
var currentOutterSuppFlow = currentSHSuppTotalFlow - currentInnerSuppFlow - currentMidSuppFlow;
|
||
|
||
(currentStep[(int)RecipColNo.SHPushTotalFlow] as DoubleParam).Value = currentSHSuppTotalFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.SHInnerFlow] as DoubleParam).Value = currentSHInnerFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.SHMiddleFlow] as DoubleParam).Value = currentSHMidFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.SHOuterFlow] as DoubleParam).Value = currentSHOutterFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.InnerPushFlow] as DoubleParam).Value = currentInnerSuppFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.MiddlePushFlow] as DoubleParam).Value = currentMidSuppFlow.ToString("F1");
|
||
(currentStep[(int)RecipColNo.OuterPushFlow] as DoubleParam).Value = currentOutterSuppFlow.ToString("F1");
|
||
|
||
#endregion
|
||
|
||
#region Vent Flow
|
||
|
||
double.TryParse((currentStep[(int)RecipColNo.TotalVentFlow] as DoubleParam).Value, out var currentTotalVentFlow);
|
||
|
||
var currentSiSourTotalFlowForPurge = (currentSiH4FlowMode != FlowMode.Run.ToString() ? currentSiH4Flow : 0)
|
||
+ (currentTCSFlowMode != FlowMode.Run.ToString() ? TCSFlow : 0) + (currentHClFlowMode != FlowMode.Run.ToString() ? currentHClFlow : 0);
|
||
|
||
var currentCSourTotalFlowForPurge = currentC2H4FlowMode != FlowMode.Run.ToString() ? currentC2H4Flow : 0;
|
||
|
||
var N2Flow = (currentN2FlowMode != FlowMode.Run.ToString() ? currentDilutedN2Flow : 0) + (currentN2HighFlowMode != FlowMode.Run.ToString() ? currentN2HighFlow : 0);
|
||
|
||
var currentDopeTotalFlowForPurge = N2Flow + (currentTMAFlowMode != FlowMode.Run.ToString() ? TMAFlow : 0);
|
||
|
||
var currentVentPushFlow = currentTotalVentFlow - currentSiSourTotalFlowForPurge - currentCSourTotalFlowForPurge - currentDopeTotalFlowForPurge;
|
||
|
||
(currentStep[(int)RecipColNo.VentPushFlow] as DoubleParam).Value = currentVentPushFlow.ToString("F1");
|
||
|
||
#endregion
|
||
}
|
||
|
||
public void TabSelectionChanged()
|
||
{
|
||
UpdateRecipeFormat();
|
||
OnViewLoaded(View);
|
||
}
|
||
|
||
public void UpdateRecipeFormat()
|
||
{
|
||
var chamber = QueryDataClient.Instance.Service.GetConfig("System.Recipe.ChamberModules");
|
||
if (chamber == null)
|
||
{
|
||
chamber = "PM1";
|
||
}
|
||
|
||
Chambers = new ObservableCollection<string>(((string)chamber).Split(','));
|
||
if (Chambers.Count > 1)
|
||
{
|
||
for (var i = 0; i < Chambers.Count; i++)
|
||
{
|
||
var isPmInstall = (bool)QueryDataClient.Instance.Service.GetConfig($"System.SetUp.Is{Chambers[i].ToString()}Installed");
|
||
{
|
||
if (!isPmInstall)
|
||
{
|
||
Chambers.RemoveAt(i);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (Chambers.Count == 0)
|
||
{
|
||
Chambers = new ObservableCollection<string>(new string[] { "PM1" });
|
||
}
|
||
SelectedChamber = Chambers[0];
|
||
|
||
if (DicColunms.Keys.Contains(CurrentProcessType))
|
||
{
|
||
this.Columns = DicColunms[CurrentProcessType];
|
||
}
|
||
else
|
||
{
|
||
this.Columns = this._columnBuilder.Build($"{CurrentChamberType}\\{CurrentProcessType}", SelectedChamber, true,ClientApp.Instance.UserContext.RoleName);
|
||
|
||
DicColunms[CurrentProcessType] = this.Columns;
|
||
}
|
||
|
||
this.CurrentRecipe = new RecipeData();
|
||
CurrentRecipe.RecipeChamberType = _columnBuilder.RecipeChamberType;
|
||
CurrentRecipe.RecipeVersion = _columnBuilder.RecipeVersion;
|
||
|
||
this.editMode = EditMode.None;
|
||
|
||
MultiChamberVisibility = Chambers.Count > 1 ? Visibility.Visible : Visibility.Collapsed;
|
||
}
|
||
|
||
public void ChamberSelectionChanged()
|
||
{
|
||
if (IsChanged)
|
||
{
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No,
|
||
DialogType.CONFIRM,
|
||
$"Recipe {CurrentRecipe.Name} is changed, do you want to save it?");
|
||
|
||
if (selection == DialogButton.Yes)
|
||
{
|
||
this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
this.CurrentRecipe.ReviseTime = DateTime.Now;
|
||
this.Save(this.CurrentRecipe, false);
|
||
}
|
||
}
|
||
|
||
CurrentRecipe.ChangeChamber(Columns
|
||
, _columnBuilder.Configs, SelectedChamber);
|
||
}
|
||
|
||
public void TreeSelectChanged(FileNode node)
|
||
{
|
||
if (IsChanged)
|
||
{
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No,
|
||
DialogType.CONFIRM,
|
||
$"Recipe {CurrentRecipe.Name} is changed, do you want to save it?");
|
||
|
||
if (selection == DialogButton.Yes)
|
||
{
|
||
this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
this.CurrentRecipe.ReviseTime = DateTime.Now;
|
||
this.Save(this.CurrentRecipe, false);
|
||
}
|
||
}
|
||
|
||
CurrentFileNode = node;
|
||
|
||
if (node != null && node.IsFile)
|
||
{
|
||
this.LoadData(node.PrefixPath, node.FullPath);
|
||
}
|
||
else
|
||
{
|
||
this.ClearData();
|
||
this.editMode = EditMode.None;
|
||
}
|
||
this.UpdateView();
|
||
//OnViewLoaded(View);//zyx debug
|
||
}
|
||
|
||
#region folder
|
||
public void NewFolder()
|
||
{
|
||
if (IsChanged)
|
||
{
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No | DialogButton.Cancel, DialogType.CONFIRM, $"Recipe {CurrentRecipe.Name} is changed, do you want to save it?");
|
||
if (selection == DialogButton.Cancel)
|
||
return;
|
||
|
||
if (selection == DialogButton.Yes)
|
||
{
|
||
this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
this.CurrentRecipe.ReviseTime = DateTime.Now;
|
||
this.Save(this.CurrentRecipe, false);
|
||
}
|
||
}
|
||
|
||
var dialog = new InputFileNameDialogViewModel("Input New Folder Name");
|
||
dialog.FileName = "new folder";
|
||
var wm = new WindowManager();
|
||
var dialogReturn = wm.ShowDialog(dialog);
|
||
if (!dialogReturn.HasValue || !dialogReturn.Value)
|
||
return;
|
||
|
||
var name = dialog.FileName.Trim();
|
||
if (string.IsNullOrEmpty(name))
|
||
{
|
||
DialogBox.ShowWarning("Folder name should not be empty");
|
||
return;
|
||
}
|
||
|
||
var prefix = ChamberType[ChamberTypeIndexSelection] + "\\" + ProcessTypeFileList[ProcessTypeIndexSelection].ProcessType;
|
||
var processType = string.Empty;
|
||
var newFolder = string.Empty;
|
||
if (CurrentFileNode != null)
|
||
{
|
||
prefix = CurrentFileNode.PrefixPath;
|
||
var folder = CurrentFileNode.FullPath;
|
||
if (CurrentFileNode.IsFile)
|
||
{
|
||
folder = folder.Substring(0, folder.LastIndexOf("\\") + 1);
|
||
if (!string.IsNullOrEmpty(folder))
|
||
newFolder = folder;
|
||
}
|
||
else
|
||
{
|
||
newFolder = folder + "\\";
|
||
}
|
||
|
||
}
|
||
|
||
newFolder = newFolder + name;
|
||
|
||
if (IsExist(newFolder, false))
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {newFolder}, Folder with the same name already exist.");
|
||
return;
|
||
}
|
||
|
||
if (newFolder.Length > 200)
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {newFolder}, Folder name too long, should be less 200.");
|
||
return;
|
||
}
|
||
|
||
_recipeProvider.CreateRecipeFolder(prefix, newFolder);
|
||
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, newFolder, true);
|
||
}
|
||
|
||
public void NewFolderRoot()
|
||
{
|
||
if (IsChanged)
|
||
{
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No | DialogButton.Cancel, DialogType.CONFIRM, $"Recipe {CurrentRecipe.Name} is changed, do you want to save it?");
|
||
if (selection == DialogButton.Cancel)
|
||
return;
|
||
|
||
if (selection == DialogButton.Yes)
|
||
{
|
||
this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
this.CurrentRecipe.ReviseTime = DateTime.Now;
|
||
this.Save(this.CurrentRecipe, false);
|
||
}
|
||
}
|
||
|
||
var dialog = new InputFileNameDialogViewModel("Input New Folder Name");
|
||
dialog.FileName = "new folder";
|
||
var wm = new WindowManager();
|
||
var dialogReturn = wm.ShowDialog(dialog);
|
||
if (!dialogReturn.HasValue || !dialogReturn.Value)
|
||
return;
|
||
|
||
var name = dialog.FileName.Trim();
|
||
if (string.IsNullOrEmpty(name))
|
||
{
|
||
DialogBox.ShowWarning("Folder name should not be empty");
|
||
return;
|
||
}
|
||
|
||
|
||
if (IsExist(name, false))
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {name}, Folder with the same name already exist.");
|
||
return;
|
||
}
|
||
|
||
if (name.Length > 200)
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {name}, Folder name too long, should be less 200.");
|
||
return;
|
||
}
|
||
|
||
var prefix = ChamberType[ChamberTypeIndexSelection] + "\\" + ProcessTypeFileList[ProcessTypeIndexSelection].ProcessType;
|
||
|
||
_recipeProvider.CreateRecipeFolder(prefix, name);
|
||
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, name, true);
|
||
}
|
||
|
||
public void DeleteFolder()
|
||
{
|
||
if (CurrentFileNode == null || CurrentFileNode.IsFile)
|
||
return;
|
||
|
||
if (CurrentFileNode.Files.Count > 0)
|
||
{
|
||
DialogBox.ShowWarning($"Can not delete non-empty folder, Remove the files or folders under \r\n{CurrentFileNode.FullPath}.");
|
||
return;
|
||
}
|
||
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM,
|
||
$"Are you sure you want to delete \r\n {CurrentFileNode.FullPath}?");
|
||
if (selection == DialogButton.No)
|
||
return;
|
||
|
||
var nextFocus = CurrentFileNode.Parent.FullPath;
|
||
var isFolder = true;
|
||
if (CurrentFileNode.Parent.Files.Count > 1)
|
||
{
|
||
for (var i = 0; i < CurrentFileNode.Parent.Files.Count; i++)
|
||
{
|
||
if (CurrentFileNode.Parent.Files[i] == CurrentFileNode)
|
||
{
|
||
if (i == 0)
|
||
{
|
||
nextFocus = CurrentFileNode.Parent.Files[i + 1].FullPath;
|
||
isFolder = !CurrentFileNode.Parent.Files[i + 1].IsFile;
|
||
}
|
||
else
|
||
{
|
||
nextFocus = CurrentFileNode.Parent.Files[i - 1].FullPath;
|
||
isFolder = !CurrentFileNode.Parent.Files[i - 1].IsFile;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
_recipeProvider.DeleteRecipeFolder(CurrentFileNode.PrefixPath, CurrentFileNode.FullPath);
|
||
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, nextFocus, isFolder);
|
||
}
|
||
|
||
public void RenameFolder()
|
||
{
|
||
if (CurrentFileNode == null || CurrentFileNode.IsFile)
|
||
return;
|
||
|
||
var dialog = new InputFileNameDialogViewModel("Input New Folder Name");
|
||
dialog.FileName = CurrentFileNode.Name;
|
||
var wm = new WindowManager();
|
||
var dialogReturn = wm.ShowDialog(dialog);
|
||
if (!dialogReturn.HasValue || !dialogReturn.Value)
|
||
return;
|
||
|
||
var name = dialog.FileName.Trim();
|
||
if (string.IsNullOrEmpty(name))
|
||
return;
|
||
|
||
var newFolder = CurrentFileNode.FullPath.Substring(0, CurrentFileNode.FullPath.LastIndexOf("\\") + 1);
|
||
if (!string.IsNullOrEmpty(newFolder))
|
||
newFolder = newFolder + name;
|
||
else
|
||
newFolder = name;
|
||
|
||
if (newFolder == CurrentFileNode.FullPath)
|
||
return;
|
||
|
||
if (IsExist(newFolder, false))
|
||
{
|
||
DialogBox.ShowWarning($"Can not rename to {newFolder}, Folder with the same name already exist.");
|
||
return;
|
||
}
|
||
|
||
if (newFolder.Length > 200)
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {newFolder}, Folder name too long, should be less 200.");
|
||
return;
|
||
}
|
||
|
||
_recipeProvider.RenameFolder(CurrentFileNode.PrefixPath, CurrentFileNode.FullPath, newFolder);
|
||
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, newFolder, true);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region recipe
|
||
public void NewRecipe()
|
||
{
|
||
if (IsChanged)
|
||
{
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No | DialogButton.Cancel, DialogType.CONFIRM, $"Recipe {CurrentRecipe.Name} is changed, do you want to save it?");
|
||
if (selection == DialogButton.Cancel)
|
||
return;
|
||
|
||
if (selection == DialogButton.Yes)
|
||
{
|
||
this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
this.CurrentRecipe.ReviseTime = DateTime.Now;
|
||
this.Save(this.CurrentRecipe, false);
|
||
}
|
||
}
|
||
|
||
var dialog = new InputFileNameDialogViewModel("Input New Name");
|
||
dialog.FileName = "";
|
||
var wm = new WindowManager();
|
||
var dialogReturn = wm.ShowDialog(dialog);
|
||
if (!dialogReturn.HasValue || !dialogReturn.Value)
|
||
return;
|
||
|
||
var recipeName = dialog.FileName.Trim();
|
||
if (string.IsNullOrEmpty(dialog.FileName))
|
||
{
|
||
DialogBox.ShowWarning("Recipe file name should not be empty");
|
||
return;
|
||
}
|
||
|
||
var prefix = CurrentChamberType + "\\" + CurrentProcessType;
|
||
var processType = string.Empty;
|
||
if (CurrentFileNode != null)
|
||
{
|
||
var folder = CurrentFileNode.FullPath;
|
||
|
||
|
||
if (CurrentFileNode.IsFile)
|
||
{
|
||
folder = folder.Substring(0, folder.LastIndexOf("\\") + 1);
|
||
//if (!string.IsNullOrEmpty(folder))
|
||
// folder = folder;
|
||
}
|
||
else
|
||
{
|
||
folder = folder + "\\";
|
||
}
|
||
recipeName = folder + recipeName;
|
||
}
|
||
|
||
if (IsExist(recipeName, true))
|
||
{
|
||
DialogBox.ShowWarning($"Can not create {recipeName}, Recipe with the same name already exist.");
|
||
return;
|
||
}
|
||
|
||
|
||
if (recipeName.Length > 200)
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {recipeName}, Folder name too long, should be less 200.");
|
||
return;
|
||
}
|
||
|
||
var recipe = new RecipeData();
|
||
recipe.Name = recipeName;
|
||
recipe.PrefixPath = prefix;
|
||
recipe.Creator = BaseApp.Instance.UserContext.LoginName;
|
||
recipe.CreateTime = DateTime.Now;
|
||
recipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
recipe.ReviseTime = DateTime.Now;
|
||
recipe.Description = string.Empty;
|
||
|
||
if (!Save(recipe, true))
|
||
return;
|
||
|
||
var types = prefix.Split('\\');
|
||
|
||
ReloadRecipeFileList(types[0], types[1], recipeName, false);
|
||
|
||
}
|
||
|
||
public void NewRecipeRoot()
|
||
{
|
||
if (IsChanged)
|
||
{
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No | DialogButton.Cancel, DialogType.CONFIRM, $"Recipe {CurrentRecipe.Name} is changed, do you want to save it?");
|
||
if (selection == DialogButton.Cancel)
|
||
return;
|
||
|
||
if (selection == DialogButton.Yes)
|
||
{
|
||
this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
this.CurrentRecipe.ReviseTime = DateTime.Now;
|
||
this.Save(this.CurrentRecipe, false);
|
||
}
|
||
}
|
||
|
||
var dialog = new InputFileNameDialogViewModel("Input New Recipe Name");
|
||
dialog.FileName = "new recipe";
|
||
var wm = new WindowManager();
|
||
var dialogReturn = wm.ShowDialog(dialog);
|
||
if (!dialogReturn.HasValue || !dialogReturn.Value)
|
||
return;
|
||
|
||
var recipeName = dialog.FileName.Trim();
|
||
if (string.IsNullOrEmpty(dialog.FileName))
|
||
{
|
||
DialogBox.ShowWarning("Recipe file name should not be empty");
|
||
return;
|
||
}
|
||
|
||
if (IsExist(recipeName, true))
|
||
{
|
||
DialogBox.ShowWarning($"Can not create {recipeName}, Recipe with the same name already exist.");
|
||
return;
|
||
}
|
||
|
||
|
||
if (recipeName.Length > 200)
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {recipeName}, Folder name too long, should be less 200.");
|
||
return;
|
||
}
|
||
|
||
var recipe = new RecipeData();
|
||
recipe.Name = recipeName;
|
||
recipe.PrefixPath = CurrentChamberType + "\\" + CurrentProcessType;
|
||
recipe.Creator = BaseApp.Instance.UserContext.LoginName;
|
||
recipe.CreateTime = DateTime.Now;
|
||
recipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
recipe.ReviseTime = DateTime.Now;
|
||
recipe.Description = string.Empty;
|
||
|
||
if (!Save(recipe, true))
|
||
return;
|
||
|
||
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, recipeName, false);
|
||
}
|
||
|
||
private void ReloadRecipeFileList(string chamberType, string processType, string selectedFile, bool selectionIsFolder)
|
||
{
|
||
var item = ProcessTypeFileList.FirstOrDefault(x => x.ProcessType == processType);
|
||
if (item == null)
|
||
{
|
||
LOG.Write("error reload recipe file list, type = " + processType);
|
||
}
|
||
|
||
var prefix = $"{ChamberType[ChamberTypeIndexSelection]}\\{item.ProcessType}";
|
||
var recipes = _recipeProvider.GetXmlRecipeList(prefix);
|
||
|
||
item.FileListByProcessType = RecipeSequenceTreeBuilder.BuildFileNode(prefix, selectedFile, selectionIsFolder, recipes)[0].Files;
|
||
item.FilterFileListByProcessType = item.FileListByProcessType;
|
||
|
||
item.InvokePropertyChanged();
|
||
}
|
||
|
||
private bool IsExist(string fullPath, bool isFile)
|
||
{
|
||
for (var i = 0; i < ProcessTypeFileList.Count; i++)
|
||
{
|
||
if (ProcessTypeFileList[i].ProcessType == CurrentProcessType)
|
||
{
|
||
if (ProcessTypeFileList[i].FileListByProcessType.Count == 0)
|
||
return false;
|
||
|
||
return FindFile(fullPath, ProcessTypeFileList[i].FileListByProcessType[0].Parent, isFile);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private bool FindFile(string path, FileNode root, bool isFile)
|
||
{
|
||
if (root.FullPath == path && !isFile)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
foreach (var node in root.Files)
|
||
{
|
||
if (isFile && node.IsFile && node.FullPath == path)
|
||
return true;
|
||
|
||
if (!node.IsFile && FindFile(path, node, isFile))
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
public void SaveAsRecipe()
|
||
{
|
||
if (CurrentFileNode == null || !CurrentFileNode.IsFile)
|
||
return;
|
||
|
||
if (IsChanged)
|
||
{
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No | DialogButton.Cancel, DialogType.CONFIRM, $"Recipe {CurrentRecipe.Name} is changed, do you want to save it?");
|
||
if (selection == DialogButton.Cancel)
|
||
return;
|
||
|
||
if (selection == DialogButton.Yes)
|
||
{
|
||
this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
this.CurrentRecipe.ReviseTime = DateTime.Now;
|
||
this.Save(this.CurrentRecipe, false);
|
||
}
|
||
}
|
||
|
||
var dialog = new InputFileNameDialogViewModel("Input New Recipe Name");
|
||
dialog.FileName = CurrentFileNode.Name;
|
||
var wm = new WindowManager();
|
||
var dialogReturn = wm.ShowDialog(dialog);
|
||
if (!dialogReturn.HasValue || !dialogReturn.Value)
|
||
return;
|
||
|
||
var recipeName = dialog.FileName.Trim();
|
||
if (string.IsNullOrEmpty(dialog.FileName))
|
||
{
|
||
DialogBox.ShowWarning("Recipe file name should not be empty");
|
||
return;
|
||
}
|
||
|
||
var prefix = CurrentChamberType + "\\" + CurrentProcessType;
|
||
var processType = string.Empty;
|
||
|
||
var folder = CurrentFileNode.FullPath;
|
||
if (CurrentFileNode.IsFile)
|
||
{
|
||
folder = folder.Substring(0, folder.LastIndexOf("\\") + 1);
|
||
}
|
||
if (!string.IsNullOrEmpty(folder))
|
||
recipeName = folder + "\\" + recipeName;
|
||
|
||
if (CurrentFileNode.FullPath == recipeName)
|
||
return;
|
||
|
||
if (IsExist(recipeName, true))
|
||
{
|
||
DialogBox.ShowWarning($"Can not copy to {recipeName}, Recipe with the same name already exist.");
|
||
return;
|
||
}
|
||
|
||
|
||
if (recipeName.Length > 200)
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {recipeName}, Folder name too long, should be less 200.");
|
||
return;
|
||
}
|
||
|
||
CurrentRecipe.Creator = BaseApp.Instance.UserContext.LoginName;
|
||
CurrentRecipe.CreateTime = DateTime.Now;
|
||
CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
CurrentRecipe.ReviseTime = DateTime.Now;
|
||
CurrentRecipe.Description = CurrentRecipe.Description + ". Renamed from " + CurrentFileNode.Name;
|
||
|
||
_recipeProvider.SaveAsRecipe(prefix, recipeName, CurrentRecipe.GetXmlString());
|
||
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, recipeName, false);
|
||
}
|
||
|
||
|
||
public void RenameRecipe()
|
||
{
|
||
if (CurrentFileNode == null || !CurrentFileNode.IsFile)
|
||
return;
|
||
|
||
if (IsChanged)
|
||
{
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No | DialogButton.Cancel, DialogType.CONFIRM, $"Recipe {CurrentRecipe.Name} is changed, do you want to save it?");
|
||
if (selection == DialogButton.Cancel)
|
||
return;
|
||
|
||
if (selection == DialogButton.Yes)
|
||
{
|
||
this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
this.CurrentRecipe.ReviseTime = DateTime.Now;
|
||
this.Save(this.CurrentRecipe, false);
|
||
}
|
||
}
|
||
|
||
var dialog = new InputFileNameDialogViewModel("Input New Recipe Name");
|
||
dialog.FileName = CurrentFileNode.Name;
|
||
var wm = new WindowManager();
|
||
var dialogReturn = wm.ShowDialog(dialog);
|
||
if (!dialogReturn.HasValue || !dialogReturn.Value)
|
||
return;
|
||
|
||
var recipeName = dialog.FileName.Trim();
|
||
if (string.IsNullOrEmpty(dialog.FileName))
|
||
{
|
||
DialogBox.ShowWarning("Recipe file name should not be empty");
|
||
return;
|
||
}
|
||
|
||
var prefix = CurrentChamberType + "\\" + CurrentProcessType;
|
||
var processType = string.Empty;
|
||
|
||
var newName = CurrentFileNode.FullPath.Substring(0, CurrentFileNode.FullPath.LastIndexOf("\\") + 1);
|
||
if (!string.IsNullOrEmpty(newName))
|
||
newName = newName + recipeName;
|
||
else
|
||
newName = recipeName;
|
||
|
||
if (newName == CurrentFileNode.FullPath)
|
||
return;
|
||
|
||
if (IsExist(newName, true))
|
||
{
|
||
DialogBox.ShowWarning($"Can not rename to {newName}, Recipe with the same name already exist.");
|
||
return;
|
||
}
|
||
|
||
|
||
if (newName.Length > 200)
|
||
{
|
||
DialogBox.ShowWarning($"Can not create folder {newName}, Folder name too long, should be less 200.");
|
||
return;
|
||
}
|
||
|
||
_recipeProvider.RenameRecipe(prefix, CurrentFileNode.FullPath, newName);
|
||
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, newName, false);
|
||
}
|
||
|
||
|
||
public void DeleteRecipe()
|
||
{
|
||
if (CurrentFileNode == null || !CurrentFileNode.IsFile)
|
||
return;
|
||
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM,
|
||
$"Are you sure you want to delete \r\n {CurrentFileNode.FullPath}?");
|
||
if (selection == DialogButton.No)
|
||
return;
|
||
|
||
var nextFocus = CurrentFileNode.Parent.FullPath;
|
||
var isFolder = true;
|
||
if (CurrentFileNode.Parent.Files.Count > 1)
|
||
{
|
||
for (var i = 0; i < CurrentFileNode.Parent.Files.Count; i++)
|
||
{
|
||
if (CurrentFileNode.Parent.Files[i] == CurrentFileNode)
|
||
{
|
||
if (i == 0)
|
||
{
|
||
nextFocus = CurrentFileNode.Parent.Files[i + 1].FullPath;
|
||
isFolder = !CurrentFileNode.Parent.Files[i + 1].IsFile;
|
||
}
|
||
else
|
||
{
|
||
nextFocus = CurrentFileNode.Parent.Files[i - 1].FullPath;
|
||
isFolder = !CurrentFileNode.Parent.Files[i - 1].IsFile;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
_recipeProvider.DeleteRecipe(CurrentFileNode.PrefixPath, CurrentFileNode.FullPath);
|
||
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, nextFocus, isFolder);
|
||
}
|
||
|
||
public void RefreshRecipe()
|
||
{
|
||
ReloadRecipeFileList(CurrentChamberType, CurrentProcessType, "", false);
|
||
}
|
||
|
||
public void ReloadRecipe()
|
||
{
|
||
if (this.editMode == EditMode.Normal || this.editMode == EditMode.Edit)
|
||
{
|
||
this.LoadData(CurrentRecipe.PrefixPath, CurrentRecipe.Name);
|
||
this.UpdateView();
|
||
}
|
||
}
|
||
|
||
public void SaveToAll()
|
||
{
|
||
LostFocusFunc();
|
||
|
||
if (!CurrentRecipe.IsCompatibleWithCurrentFormat)
|
||
{
|
||
DialogBox.ShowWarning($"Save failed, {CurrentRecipe.Name} is not a valid recipe file");
|
||
return;
|
||
}
|
||
|
||
var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No,
|
||
DialogType.CONFIRM, $"Do you want to save to all? \r\n This will replace all the other chamber recipe content");
|
||
if (selection == DialogButton.No)
|
||
return;
|
||
|
||
CurrentRecipe.SaveTo(Chambers.ToArray());
|
||
|
||
Save(this.CurrentRecipe, false);
|
||
}
|
||
|
||
public void SaveTo()
|
||
{
|
||
LostFocusFunc();
|
||
|
||
if (!CurrentRecipe.IsCompatibleWithCurrentFormat)
|
||
{
|
||
DialogBox.ShowWarning($"Save failed, {CurrentRecipe.Name} is not a valid recipe file");
|
||
return;
|
||
}
|
||
|
||
var dialog = new SaveToDialogViewModel("Select which chamber to copy to", SelectedChamber, Chambers.ToList());
|
||
|
||
var wm = new WindowManager();
|
||
var dialogReturn = wm.ShowDialog(dialog);
|
||
if (!dialogReturn.HasValue || !dialogReturn.Value)
|
||
return;
|
||
|
||
var chambers = new List<string>();
|
||
foreach (var dialogChamber in dialog.Chambers)
|
||
{
|
||
if (dialogChamber.IsEnabled && dialogChamber.IsChecked)
|
||
chambers.Add(dialogChamber.Name);
|
||
}
|
||
|
||
if (chambers.Count == 0)
|
||
return;
|
||
|
||
CurrentRecipe.SaveTo(chambers.ToArray());
|
||
|
||
Save(this.CurrentRecipe, false);
|
||
}
|
||
#endregion
|
||
|
||
#region Steps
|
||
|
||
public void ParamsExpanded(ExpanderColumn col)
|
||
{
|
||
var index = this.Columns.IndexOf(col);
|
||
for (var i = index + 1; i < this.Columns.Count; i++)
|
||
{
|
||
if (this.Columns[i] is ExpanderColumn)
|
||
break;
|
||
this.Columns[i].Visibility = Visibility.Visible;
|
||
}
|
||
}
|
||
|
||
public void ParamsCollapsed(ExpanderColumn col)
|
||
{
|
||
var index = this.Columns.IndexOf(col);
|
||
for (var i = index + 1; i < this.Columns.Count; i++)
|
||
{
|
||
if (this.Columns[i] is ExpanderColumn)
|
||
break;
|
||
this.Columns[i].Visibility = Visibility.Collapsed;
|
||
}
|
||
}
|
||
|
||
public bool CheckColumnDataAvalible()
|
||
{
|
||
if (CurrentProcessType == ProcessTypeFileList[1].ProcessType)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
var lstNotCorrectInfo = new List<string>();
|
||
var lstOutOfRange = new List<string>();
|
||
|
||
var lstSplitColums = new List<int>() { (int)RecipColNo.SHTotalFlowSplitRatio, (int)RecipColNo.SiSourceSplitRatio, (int)RecipColNo.CSourceSplitRatio, (int)RecipColNo.DopeSplitRatio };
|
||
|
||
for (var a = 0; a < this.CurrentRecipe.Steps.Count; a++)
|
||
{
|
||
for (var i = 0; i < this.Columns.Count; i++)
|
||
{
|
||
if (this.Columns[i] is DoubleColumn)
|
||
{
|
||
var column = (DoubleColumn)this.Columns[i];
|
||
var maxValue = column.Maximun;
|
||
var minValue = column.Minimun;
|
||
|
||
if (maxValue != minValue)
|
||
{
|
||
double cValue = 0;
|
||
if (!double.TryParse((this.CurrentRecipe.Steps[a][i] as DoubleParam).Value, out cValue))
|
||
{
|
||
if ((this.CurrentRecipe.Steps[a][i] as DoubleParam).Value != "Hold")
|
||
{
|
||
lstNotCorrectInfo.Add($"Step {a + 1} {column.DisplayName}: value {(this.CurrentRecipe.Steps[a][i] as DoubleParam).Value} is incorrect numerical format ");
|
||
(this.CurrentRecipe.Steps[a][i] as DoubleParam).Foreground = "Red";
|
||
}
|
||
}
|
||
else if (cValue > maxValue || cValue < minValue)
|
||
{
|
||
lstOutOfRange.Add($"Step {a + 1} {column.DisplayName}: value {cValue} is out of range {minValue}-{maxValue}");
|
||
(this.CurrentRecipe.Steps[a][i] as DoubleParam).Foreground = "Red";
|
||
}
|
||
}
|
||
}
|
||
else if (lstSplitColums.Contains(i))
|
||
{
|
||
double a1 = 0;
|
||
double a2 = 0;
|
||
double a3 = 0;
|
||
var arrSplitRatio = (this.CurrentRecipe.Steps[a][i] as StringParam).Value.Split(':');
|
||
if (arrSplitRatio.Length != 3
|
||
|| !double.TryParse(arrSplitRatio[0], out a1) || !double.TryParse(arrSplitRatio[1], out a2) || !double.TryParse(arrSplitRatio[2], out a3)
|
||
|| a1 <= 0 || a2 <= 0 || a3 <= 0)
|
||
{
|
||
lstNotCorrectInfo.Add($"(Step {i + 1}) {this.Columns[i].DisplayName}: value is not avalible!");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (lstNotCorrectInfo.Count > 0 || lstOutOfRange.Count > 0)
|
||
{
|
||
var strInfo = "";
|
||
for (var i = 0; i < lstNotCorrectInfo.Count; i++)
|
||
{
|
||
strInfo += lstNotCorrectInfo[i] + "\r\n";
|
||
}
|
||
for (var i = 0; i < lstOutOfRange.Count; i++)
|
||
{
|
||
strInfo += lstOutOfRange[i] + "\r\n";
|
||
}
|
||
MessageBox.Show(strInfo);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
public void SaveRecipe()
|
||
{
|
||
//if (!CheckColumnDataAvalible())
|
||
//{
|
||
// return;
|
||
//}
|
||
|
||
//if (this.IsChanged)
|
||
//{
|
||
this.Save(this.CurrentRecipe, false);
|
||
//}
|
||
}
|
||
|
||
public void PopSetting(string controlName, Param paramData)
|
||
{
|
||
var stepNum = Convert.ToInt32(((StepParam)paramData.Parent[1]).Value);
|
||
|
||
var dialog = new PublicPopSettingDialogViewModel();
|
||
dialog.DisplayName = paramData.DisplayName;
|
||
var Parameters = new ObservableCollection<Param>();
|
||
|
||
Parameters = this.CurrentRecipe.PopSettingSteps[controlName][stepNum - 1];
|
||
|
||
var ControlParameters = new ObservableCollection<Param>();
|
||
var BrandParameters = new ObservableCollection<BandParam>();
|
||
foreach (var item in Parameters)
|
||
{
|
||
if (item.Name.Contains("Band"))
|
||
{
|
||
var name = item.Name.Replace("Wavelength", "").Replace("Bandwidth", "");
|
||
var displayName = item.DisplayName.Replace("Wavelength", "").Replace("Bandwidth", "");
|
||
|
||
if (BrandParameters.Where(x => x.Name == name).Count() == 0)
|
||
{
|
||
BrandParameters.Add(new BandParam()
|
||
{
|
||
Name = name,
|
||
DisplayName = displayName
|
||
});
|
||
}
|
||
|
||
if (item.Name.Contains("Wavelength"))
|
||
{
|
||
BrandParameters.First(x => x.Name == name).WavelengthDoubleParam = item;
|
||
}
|
||
else if (item.Name.Contains("Bandwidth"))
|
||
{
|
||
BrandParameters.First(x => x.Name == name).BandwidthDoubleParam = item;
|
||
}
|
||
}
|
||
else
|
||
ControlParameters.Add(item);
|
||
}
|
||
|
||
dialog.Parameters = Parameters;
|
||
dialog.ControlParameters = ControlParameters;
|
||
dialog.BandParameters = BrandParameters;
|
||
|
||
var wm = new WindowManager();
|
||
var bret = wm.ShowDialog(dialog);
|
||
if ((bool)bret)
|
||
{
|
||
this.CurrentRecipe.PopSettingSteps[controlName][stepNum - 1] = dialog.Parameters;
|
||
}
|
||
}
|
||
|
||
public bool Save(RecipeData recipe, bool createNew)
|
||
{
|
||
//保存时也要失去焦点计算一次
|
||
LostFocusFunc();
|
||
|
||
if (!CheckColumnDataAvalible())
|
||
{
|
||
//return false;
|
||
}
|
||
|
||
var result = false;
|
||
if (string.IsNullOrEmpty(recipe.Name))
|
||
{
|
||
MessageBox.Show("Recipe name can't be empty");
|
||
return false;
|
||
}
|
||
|
||
recipe.Revisor = BaseApp.Instance.UserContext.LoginName;
|
||
recipe.ReviseTime = DateTime.Now;
|
||
|
||
result = this._recipeProvider.SaveRecipe(recipe.PrefixPath, recipe.Name, recipe.GetXmlString());
|
||
|
||
if (result)
|
||
{
|
||
recipe.DataSaved();
|
||
|
||
this.editMode = EditMode.Normal;
|
||
|
||
this.UpdateView();
|
||
}
|
||
else
|
||
{
|
||
MessageBox.Show("Save failed!");
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
public void AddStep()
|
||
{
|
||
this.CurrentRecipe.Steps.Add(this.CurrentRecipe.CreateStep(this.Columns));
|
||
|
||
if (this.editMode != EditMode.New && this.editMode != EditMode.ReName)
|
||
this.editMode = EditMode.Edit;
|
||
|
||
var index = 1;
|
||
foreach (var parameters in this.CurrentRecipe.Steps)
|
||
{
|
||
(parameters[1] as StepParam).Value = index.ToString();
|
||
index++;
|
||
}
|
||
this.UpdateView();
|
||
}
|
||
|
||
public void AppendStep()
|
||
{
|
||
var index = -1;
|
||
var found = false;
|
||
for (var i = 0; i < this.CurrentRecipe.Steps.Count; i++)
|
||
{
|
||
if (this.CurrentRecipe.Steps[i][1] is StepParam && ((StepParam)this.CurrentRecipe.Steps[i][1]).Checked)
|
||
{
|
||
index = i;
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
if (found)
|
||
{
|
||
if (this.editMode != EditMode.New && this.editMode != EditMode.ReName)
|
||
this.editMode = EditMode.Edit;
|
||
|
||
this.CurrentRecipe.Steps.Insert(index, this.CurrentRecipe.CreateStep(this.Columns));
|
||
|
||
|
||
index = 1;
|
||
foreach (var parameters in this.CurrentRecipe.Steps)
|
||
{
|
||
(parameters[1] as StepParam).Value = index.ToString();
|
||
index++;
|
||
}
|
||
}
|
||
}
|
||
|
||
private ObservableCollection<ObservableCollection<Param>> copySteps = new ObservableCollection<ObservableCollection<Param>>();
|
||
private Dictionary<string, ObservableCollection<ObservableCollection<Param>>> popCopySteps = new Dictionary<string, ObservableCollection<ObservableCollection<Param>>>();
|
||
|
||
public void CopyStep()
|
||
{
|
||
this.copySteps.Clear();
|
||
this.popCopySteps.Clear();
|
||
|
||
for (var i = 0; i < this.CurrentRecipe.Steps.Count; i++)
|
||
{
|
||
if (this.CurrentRecipe.Steps[i][1] is StepParam && ((StepParam)this.CurrentRecipe.Steps[i][1]).Checked)
|
||
{
|
||
this.copySteps.Add(this.CurrentRecipe.CloneStep(this.Columns, this.CurrentRecipe.Steps[i]));
|
||
}
|
||
}
|
||
CurrentRecipe.ValidLoopData();
|
||
}
|
||
|
||
public void PasteFrontStep()
|
||
{
|
||
if (this.copySteps.Count > 0)
|
||
{
|
||
if (this.editMode != EditMode.New && this.editMode != EditMode.ReName)
|
||
this.editMode = EditMode.Edit;
|
||
for (var i = 0; i < this.CurrentRecipe.Steps.Count; i++)
|
||
{
|
||
if (this.CurrentRecipe.Steps[i][1] is StepParam && ((StepParam)this.CurrentRecipe.Steps[i][1]).Checked)
|
||
{
|
||
for (var copyindex = 0; copyindex < this.copySteps.Count; copyindex++)
|
||
{
|
||
this.CurrentRecipe.Steps.Insert(i, this.CurrentRecipe.CloneStep(this.Columns, this.copySteps[copyindex]));
|
||
i++;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
var index = 1;
|
||
foreach (var parameters in this.CurrentRecipe.Steps)
|
||
{
|
||
(parameters[1] as StepParam).Value = index.ToString();
|
||
index++;
|
||
}
|
||
CurrentRecipe.ValidLoopData();
|
||
this.UpdateView();
|
||
}
|
||
}
|
||
public void PasteBackStep()
|
||
{
|
||
if (this.copySteps.Count > 0)
|
||
{
|
||
if (this.editMode != EditMode.New && this.editMode != EditMode.ReName)
|
||
this.editMode = EditMode.Edit;
|
||
for (var i = this.CurrentRecipe.Steps.Count - 1; i >= 0; i--)
|
||
{
|
||
if (this.CurrentRecipe.Steps[i][1] is StepParam && ((StepParam)this.CurrentRecipe.Steps[i][1]).Checked)
|
||
{
|
||
for (var copyindex = 0; copyindex < this.copySteps.Count; copyindex++)
|
||
{
|
||
this.CurrentRecipe.Steps.Insert(i + 1, this.CurrentRecipe.CloneStep(this.Columns, this.copySteps[copyindex]));
|
||
i++;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
var index = 1;
|
||
foreach (var parameters in this.CurrentRecipe.Steps)
|
||
{
|
||
(parameters[1] as StepParam).Value = index.ToString();
|
||
index++;
|
||
}
|
||
CurrentRecipe.ValidLoopData();
|
||
this.UpdateView();
|
||
}
|
||
}
|
||
|
||
public void DeleteStep()
|
||
{
|
||
if (this.editMode != EditMode.New && this.editMode != EditMode.ReName)
|
||
this.editMode = EditMode.Edit;
|
||
|
||
var steps = this.CurrentRecipe.Steps.ToList();
|
||
|
||
for (var i = 0; i < steps.Count; i++)
|
||
{
|
||
if (steps[i][1] is StepParam && ((StepParam)steps[i][1]).Checked)
|
||
{
|
||
this.CurrentRecipe.Steps.Remove(steps[i]);
|
||
}
|
||
}
|
||
var index = 1;
|
||
foreach (var parameters in this.CurrentRecipe.Steps)
|
||
{
|
||
(parameters[1] as StepParam).Value = index.ToString();
|
||
index++;
|
||
}
|
||
}
|
||
|
||
private TreeViewItem GetParentObjectEx<TreeViewItem>(DependencyObject obj) where TreeViewItem : FrameworkElement
|
||
{
|
||
var parent = VisualTreeHelper.GetParent(obj);
|
||
while (parent != null)
|
||
{
|
||
if (parent is TreeViewItem)
|
||
{
|
||
return (TreeViewItem)parent;
|
||
}
|
||
parent = VisualTreeHelper.GetParent(parent);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public void TreeRightMouseDown(MouseButtonEventArgs e)
|
||
{
|
||
var item = GetParentObjectEx<TreeViewItem>(e.OriginalSource as DependencyObject) as TreeViewItem;
|
||
if (item != null)
|
||
{
|
||
item.Focus();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
#endregion
|
||
private void ClearData()
|
||
{
|
||
this.editMode = EditMode.None;
|
||
this.CurrentRecipe.Clear();
|
||
this.CurrentRecipe.Name = string.Empty;
|
||
this.CurrentRecipe.Description = string.Empty;
|
||
}
|
||
|
||
private void LoadData(string prefixPath, string recipeName)
|
||
{
|
||
CurrentRecipe.Clear();
|
||
|
||
var recipeContent = _recipeProvider.LoadRecipe(prefixPath, recipeName);
|
||
|
||
if (string.IsNullOrEmpty(recipeContent))
|
||
{
|
||
MessageBox.Show($"{prefixPath}\\{recipeName} is empty, please confirm the file is valid.");
|
||
return;
|
||
}
|
||
|
||
CurrentRecipe.RecipeChamberType = _columnBuilder.RecipeChamberType;
|
||
CurrentRecipe.RecipeVersion = _columnBuilder.RecipeVersion;
|
||
CurrentRecipe.InitData(prefixPath, recipeName, recipeContent, Columns,
|
||
_columnBuilder.Configs, SelectedChamber);
|
||
|
||
this.editMode = EditMode.Normal;
|
||
}
|
||
|
||
private void UpdateView()
|
||
{
|
||
var isFileSelected = CurrentFileNode != null && CurrentFileNode.IsFile;
|
||
|
||
this.EnableNew = isFileSelected;
|
||
this.EnableReName = isFileSelected;
|
||
this.EnableCopy = isFileSelected;
|
||
this.EnableDelete = isFileSelected;
|
||
this.EnableSave = isFileSelected;
|
||
this.EnableStep = isFileSelected;
|
||
EnableSaveTo = isFileSelected;
|
||
EnableSaveToAll = isFileSelected;
|
||
|
||
if (this.editMode == EditMode.None)
|
||
{
|
||
this.EnableNew = true;
|
||
this.EnableReName = false;
|
||
this.EnableCopy = false;
|
||
this.EnableDelete = false;
|
||
this.EnableStep = false;
|
||
this.EnableSave = false;
|
||
|
||
}
|
||
|
||
this.NotifyOfPropertyChange("EnableNew");
|
||
this.NotifyOfPropertyChange("EnableReName");
|
||
this.NotifyOfPropertyChange("EnableCopy");
|
||
this.NotifyOfPropertyChange("EnableDelete");
|
||
this.NotifyOfPropertyChange("EnableSave");
|
||
this.NotifyOfPropertyChange("EnableStep");
|
||
this.NotifyOfPropertyChange("EnableSaveTo");
|
||
this.NotifyOfPropertyChange("EnableSaveToAll");
|
||
this.NotifyOfPropertyChange("EnableReload");
|
||
|
||
this.NotifyOfPropertyChange("CurrentRecipe");
|
||
}
|
||
|
||
private string _currentCriteria = String.Empty;
|
||
public string CurrentCriteria
|
||
{
|
||
get { return _currentCriteria; }
|
||
set
|
||
{
|
||
if (value == _currentCriteria)
|
||
return;
|
||
|
||
_currentCriteria = value;
|
||
NotifyOfPropertyChange("CurrentCriteria");
|
||
ApplyFilter();
|
||
}
|
||
}
|
||
private void ApplyFilter()
|
||
{
|
||
ProcessTypeFileList[ProcessTypeIndexSelection].FilterFileListByProcessType =
|
||
new ObservableCollection<FileNode>(ProcessTypeFileList[ProcessTypeIndexSelection].FileListByProcessType.
|
||
Where(d => d.Name.IndexOf(CurrentCriteria, StringComparison.OrdinalIgnoreCase) >= 0));
|
||
}
|
||
|
||
public void ClearFilter()
|
||
{
|
||
CurrentCriteria = "";
|
||
}
|
||
|
||
}
|
||
}
|