using CommunityToolkit.Mvvm.ComponentModel;
|
using CommunityToolkit.Mvvm.Input;
|
using HMI.Core.Util;
|
using HMI.UI;
|
using HMI.UI.Util;
|
using log4net;
|
using Microsoft.Win32;
|
using NationalInstruments.TestStand.Interop.API;
|
using Plugin.SeqEditor.Constant;
|
using Plugin.SeqEditor.Entity;
|
using Plugin.SeqEditor.Util;
|
using System.Collections.ObjectModel;
|
using System.IO;
|
|
namespace Plugin.SeqEditor.ViewModel
|
{
|
|
public partial class SeqEditorViewModel : ObservableObject
|
{
|
private ObservableCollection<StepUI> setupSteps = new ObservableCollection<StepUI>();
|
|
private ObservableCollection<StepUI> mainSteps = new ObservableCollection<StepUI>();
|
|
private ObservableCollection<StepUI> cleanupSteps = new ObservableCollection<StepUI>();
|
|
[ObservableProperty]
|
private ObservableCollection<StepUI> allSteps = new ObservableCollection<StepUI>();
|
|
[ObservableProperty]
|
private ObservableCollection<SeqUI> sequences = new ObservableCollection<SeqUI>();
|
|
[ObservableProperty]
|
private SeqUI currentSeqUI;
|
|
[ObservableProperty]
|
private StepUI currentStepUI;
|
|
[ObservableProperty]
|
private string currentFileName;
|
|
[ObservableProperty]
|
private string currentSeqTitle = LangUtil.Get("se.steps");
|
|
[ObservableProperty]
|
private string targetType = null;
|
|
|
private string currentFilePath;
|
private Engine engine;
|
private SequenceFile sequenceFile;
|
private bool isLoaded;
|
private ILog log;
|
public SeqEditor control { get; private set; }
|
|
public List<ItemData> Types = FilterTypeData.ItemSource;
|
|
private HashSet<string> edits = new HashSet<string> {
|
StepTypeStr.PassFailTest,
|
StepTypeStr.NumericLimitTest,
|
StepTypeStr.NI_MultipleNumericLimitTest,
|
StepTypeStr.StringValueTest,
|
StepTypeStr.Action,
|
StepTypeStr.NI_Wait,
|
StepTypeStr.SequenceCall,
|
};
|
|
public SeqEditorViewModel(SeqEditor control, ILog log)
|
{
|
this.log = log;
|
this.control = control;
|
engine = new Engine();
|
engine.LoadTypePaletteFilesEx();
|
}
|
|
~SeqEditorViewModel()
|
{
|
if (engine != null)
|
{
|
if (sequenceFile != null)
|
{
|
engine.ReleaseSequenceFileEx(sequenceFile);
|
}
|
engine.ShutDown(true);
|
// 不加延时会弹窗md
|
System.Threading.Thread.Sleep(2500);
|
}
|
}
|
|
private ObservableCollection<StepUI> LoadSteps(Sequence seq, string group = null)
|
{
|
//setupSteps.Clear();
|
//var steps = new ObservableCollection<StepUI>();
|
//int num = seq.GetNumSteps(StepGroups.StepGroup_Setup);
|
//for (int i = 0; i < num; i++)
|
//{
|
// Step step = seq.GetStep(i, StepGroups.StepGroup_Setup);
|
// var ui = new StepUI(step);
|
// if (edits.Contains(ui.Type))
|
// {
|
// setupSteps.Add(ui);
|
// steps.Add(ui);
|
// }
|
//}
|
////SetupSteps = steps;
|
////steps = new ObservableCollection<StepUI>();
|
//mainSteps.Clear();
|
//num = seq.GetNumSteps(StepGroups.StepGroup_Main);
|
//for (int i = 0; i < num; i++)
|
//{
|
// Step step = seq.GetStep(i, StepGroups.StepGroup_Main);
|
// var ui = new StepUI(step);
|
// if (edits.Contains(ui.Type))
|
// {
|
// mainSteps.Add(ui);
|
// steps.Add(ui);
|
// }
|
//}
|
////MainSteps = steps;
|
////steps = new ObservableCollection<StepUI>();
|
//cleanupSteps.Clear();
|
//num = seq.GetNumSteps(StepGroups.StepGroup_Cleanup);
|
//for (int i = 0; i < num; i++)
|
//{
|
// Step step = seq.GetStep(i, StepGroups.StepGroup_Cleanup);
|
// var ui = new StepUI(step);
|
// if (edits.Contains(ui.Type))
|
// {
|
// cleanupSteps.Add(ui);
|
// steps.Add(ui);
|
// }
|
//}
|
//AllSteps = steps;
|
//CurrentStepUI = null;
|
|
var steps = new ObservableCollection<StepUI>();
|
|
int num = seq.GetNumSteps(StepGroups.StepGroup_Setup);
|
for (int i = 0; i < num; i++)
|
{
|
Step step = seq.GetStep(i, StepGroups.StepGroup_Setup);
|
var ui = Convert2StepUI(step, group);
|
if (ui != null)
|
{
|
steps.Add(ui);
|
}
|
}
|
|
num = seq.GetNumSteps(StepGroups.StepGroup_Main);
|
for (int i = 0; i < num; i++)
|
{
|
Step step = seq.GetStep(i, StepGroups.StepGroup_Main);
|
var ui = Convert2StepUI(step, group);
|
if (ui != null)
|
{
|
steps.Add(ui);
|
}
|
}
|
|
num = seq.GetNumSteps(StepGroups.StepGroup_Cleanup);
|
for (int i = 0; i < num; i++)
|
{
|
Step step = seq.GetStep(i, StepGroups.StepGroup_Cleanup);
|
var ui = Convert2StepUI(step, group);
|
if (ui != null)
|
{
|
steps.Add(ui);
|
}
|
}
|
return steps;
|
}
|
|
private StepUI Convert2StepUI(Step step, string group)
|
{
|
var ui = new StepUI(step);
|
if (!edits.Contains(ui.Type))
|
{
|
return null;
|
}
|
|
if (string.IsNullOrEmpty(group))
|
{
|
if (ui.StepGroup == StepGroups.StepGroup_Setup)
|
{
|
group = "Setup";
|
}
|
else if (ui.StepGroup == StepGroups.StepGroup_Main)
|
{
|
group = "Main";
|
}
|
else if (ui.StepGroup == StepGroups.StepGroup_Cleanup)
|
{
|
group = "Cleanup";
|
}
|
else
|
{
|
group = "Unkown";
|
}
|
}
|
ui.Group = group;
|
|
if (ui.Type == StepTypeStr.SequenceCall)
|
{
|
var po = step.Module.AsPropertyObject();
|
bool useCurFile = po.GetValBoolean("UseCurFile", 0);
|
if (useCurFile)
|
{
|
string seqName = po.GetValString("SeqName", 0);
|
Sequence sequence = sequenceFile.GetSequenceByName(seqName);
|
if (sequence == null)
|
{
|
return ui;
|
}
|
ui.Children = LoadSteps(sequence, group);
|
}
|
}
|
return ui;
|
}
|
|
|
[RelayCommand]
|
private void Loaded()
|
{
|
if (!isLoaded)
|
{
|
}
|
}
|
|
[RelayCommand]
|
private void OpenSeqFile()
|
{
|
OpenFileDialog ofd = new OpenFileDialog()
|
{
|
Filter = $"{LangUtil.Get("se.seq")}|*.seq;"
|
};
|
if (ofd.ShowDialog() == true)
|
{
|
control.BackgroundAction(() =>
|
{
|
try
|
{
|
var start = DateTime.Now;
|
currentFilePath = ofd.FileName;
|
CurrentFileName = $"{LangUtil.Get("se.currentFile")}{Path.GetFileName(currentFilePath)}";
|
if (sequenceFile != null)
|
{
|
engine.ReleaseSequenceFileEx(sequenceFile);
|
}
|
sequenceFile = engine.GetSequenceFileEx(currentFilePath);
|
Sequence main = sequenceFile.GetSequenceByName("MainSequence");
|
CurrentSeqUI = new SeqUI(main);
|
|
//var seqs = new ObservableCollection<SeqUI>();
|
//for (int i = 0; i < sequenceFile.NumSequences; i++)
|
//{
|
// var tsSequence = sequenceFile.GetSequence(i);
|
// seqs.Add(new SeqUI(tsSequence));
|
//}
|
//Sequences = seqs;
|
|
if (Sequences != null && Sequences.Count > 0)
|
{
|
CurrentSeqUI = Sequences[0];
|
}
|
log.Info($"Open File [{currentFilePath}] In {(DateTime.Now - start).TotalMilliseconds}ms");
|
}
|
catch (Exception ex)
|
{
|
|
}
|
}, LangUtil.Get("se.seqIsLoading"));
|
}
|
}
|
|
[RelayCommand]
|
private void SaveSeqFile()
|
{
|
sequenceFile?.Save(currentFilePath);
|
}
|
|
[RelayCommand]
|
private void Refresh()
|
{
|
if (CurrentSeqUI == null) return;
|
if (string.IsNullOrEmpty(TargetType))
|
{
|
edits = new HashSet<string> {
|
StepTypeStr.PassFailTest,
|
StepTypeStr.NumericLimitTest,
|
StepTypeStr.NI_MultipleNumericLimitTest,
|
StepTypeStr.StringValueTest,
|
StepTypeStr.Action,
|
StepTypeStr.NI_Wait,
|
StepTypeStr.SequenceCall,
|
};
|
}
|
else
|
{
|
edits = new HashSet<string>(TargetType.Split(','))
|
{
|
StepTypeStr.SequenceCall
|
};
|
}
|
AllSteps = LoadSteps(CurrentSeqUI.sequence);
|
}
|
|
[RelayCommand]
|
private void CloseSeqFile()
|
{
|
//AllSteps = new ObservableCollection<StepUI>();
|
if (engine != null && sequenceFile != null)
|
{
|
engine.ReleaseSequenceFileEx(sequenceFile);
|
sequenceFile = null;
|
}
|
setupSteps.Clear();
|
mainSteps.Clear();
|
cleanupSteps.Clear();
|
AllSteps = new();
|
Sequences.Clear();
|
currentFilePath = string.Empty;
|
CurrentFileName = string.Empty;
|
CurrentSeqUI = null;
|
CurrentStepUI = null;
|
CurrentSeqTitle = LangUtil.Get("se.steps");
|
}
|
|
[RelayCommand]
|
private void AddStep(string type)
|
{
|
try
|
{
|
var group = CurrentStepUI.step.StepGroup;
|
|
ObservableCollection<StepUI> source;
|
if (group == StepGroups.StepGroup_Setup)
|
{
|
source = setupSteps;
|
}
|
else if (group == StepGroups.StepGroup_Main)
|
{
|
source = mainSteps;
|
}
|
else
|
{
|
source = cleanupSteps;
|
}
|
int index = source.IndexOf(CurrentStepUI);
|
if (index < 0)
|
{
|
return;
|
}
|
Step newStep;
|
switch (type)
|
{
|
case "Tests.PassFail":
|
newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.PassFailTest);
|
newStep.Name = DefaultStepName.PassFailTest;
|
var p = newStep.AsPropertyObject();
|
string name = p.Name;
|
var ps = p.GetSubProperties("", 0);
|
foreach (var pp in ps)
|
{
|
string sname = pp.Name;
|
}
|
|
break;
|
case "Tests.NumericLimitTest":
|
newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.NumericLimitTest);
|
newStep.Name = DefaultStepName.NumericLimitTest;
|
break;
|
case "Tests.NI_MultipleNumericLimitTest":
|
newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.NI_MultipleNumericLimitTest);
|
newStep.Name = DefaultStepName.NI_MultipleNumericLimitTest;
|
break;
|
case "Tests.StringValueTest":
|
newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.StringValueTest);
|
newStep.Name = DefaultStepName.StringValueTest;
|
break;
|
case "Actions.LabVIEW":
|
newStep = engine.NewStep(AdapterKeyNames.FlexLVAdapterKeyName, StepTypeStr.Action);
|
newStep.Name = DefaultStepName.Action;
|
break;
|
case "Actions.LabWindows/CVI":
|
newStep = engine.NewStep(AdapterKeyNames.FlexCVIAdapterKeyName, StepTypeStr.Action);
|
newStep.Name = DefaultStepName.Action;
|
break;
|
case "Actions.C/C++ DLL":
|
newStep = engine.NewStep(AdapterKeyNames.FlexCAdapterKeyName, StepTypeStr.Action);
|
newStep.Name = DefaultStepName.Action;
|
break;
|
case "Actions..NET":
|
newStep = engine.NewStep(AdapterKeyNames.DotNetAdapterKeyname, StepTypeStr.Action);
|
newStep.Name = DefaultStepName.Action;
|
break;
|
case "Actions.ActiveX/COM":
|
newStep = engine.NewStep(AdapterKeyNames.AutomationAdapterKeyName, StepTypeStr.Action);
|
newStep.Name = DefaultStepName.Action;
|
break;
|
case "Actions.None":
|
newStep = engine.NewStep(AdapterKeyNames.NoneAdapterKeyName, StepTypeStr.Action);
|
newStep.Name = DefaultStepName.Action;
|
break;
|
case "Actions.LabVIEW NXG":
|
newStep = engine.NewStep(AdapterKeyNames.LabVIEWNXGAdapterKeyName, StepTypeStr.Action);
|
newStep.Name = DefaultStepName.Action;
|
break;
|
case "Actions.Python":
|
newStep = engine.NewStep(AdapterKeyNames.PythonAdapterKeyName, StepTypeStr.Action);
|
newStep.Name = DefaultStepName.Action;
|
break;
|
|
default:
|
return;
|
}
|
CurrentSeqUI.sequence.InsertStep(newStep, index + 1, group);
|
AllSteps = LoadSteps(CurrentSeqUI.sequence);
|
}
|
catch (Exception ex)
|
{
|
log.Error("Insert Step Error.", ex);
|
MsgBoxHelper2.Error(ex.Message);
|
}
|
}
|
|
[ObservableProperty]
|
private TreeItemData treeItemData;
|
|
partial void OnTreeItemDataChanged(TreeItemData data)
|
{
|
CurrentStepUI = data?.Data as StepUI;
|
}
|
|
partial void OnCurrentStepUIChanged(StepUI stepUI)
|
{
|
var panel = StepUI2EPO.Convert2EditPanel(stepUI);
|
control.editPanelContainer.Child = panel;
|
if (stepUI != null)
|
{
|
|
//window.commonP.RefreshStep(stepUI);
|
}
|
}
|
|
partial void OnCurrentSeqUIChanged(SeqUI seqUI)
|
{
|
if (seqUI != null)
|
{
|
CurrentStepUI = null;
|
AllSteps = LoadSteps(seqUI.sequence);
|
}
|
CurrentSeqTitle = $"{seqUI?.Name} {LangUtil.Get("se.steps")}";
|
}
|
}
|
}
|
