1183 lines
51 KiB
C#
1183 lines
51 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Media;
|
|
using System.Xml.Linq;
|
|
using DTS.Common;
|
|
using DTS.Common.Base;
|
|
using DTS.Common.Classes.Viewer.TestMetadata;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Events;
|
|
using DTS.Common.Interactivity;
|
|
using DTS.Common.Interface;
|
|
using DTS.Common.Interface.TestDefinition;
|
|
using DTS.Common.Strings;
|
|
using DTS.Common.Utilities.Logging;
|
|
using DTS.Common.Utils;
|
|
using Prism.Events;
|
|
using Prism.Regions;
|
|
using Unity;
|
|
// ReSharper disable AutoPropertyCanBeMadeGetOnly.Local
|
|
// ReSharper disable CheckNamespace
|
|
// ReSharper disable NotAccessedField.Local
|
|
// ReSharper disable InconsistentNaming
|
|
// ReSharper disable UnusedMember.Local
|
|
// ReSharper disable RedundantDefaultMemberInitializer
|
|
// ReSharper disable RedundantAssignment
|
|
|
|
namespace DTS.Viewer.GraphList
|
|
{
|
|
public class ExportGraphMainViewModel : BaseViewModel<IExportGraphMainViewModel>, IExportGraphMainViewModel
|
|
{
|
|
public IFilterView FilterView { get; private set; }
|
|
public IExportGraphMainView View { get; set; }
|
|
public IBaseViewModel Parent { get; set; }
|
|
public bool SettingChildNodesToTrue { get; set; }
|
|
public bool SettingOrResettingChildNodes { get; set; }
|
|
public bool SettingPeerNodeToTrue { get; set; }
|
|
public bool SettingItemsBetween { get; set; }
|
|
public bool ResettingAllItems { get; set; }
|
|
private IEventAggregator _eventAggregator { get; set; }
|
|
private IUnityContainer _unityContainer { get; set; }
|
|
private bool _showIsoCodes = false;
|
|
public InteractionRequest<Notification> NotificationRequest { get; private set; }
|
|
public new InteractionRequest<Confirmation> ConfirmationRequest { get; private set; }
|
|
|
|
|
|
/// <summary>
|
|
/// Creates a new instance of the ExportGraphMainViewModel.
|
|
/// </summary>
|
|
/// <param name="view">The ExportGraphMainView interface.</param>
|
|
/// <param name="regionManager">The logical placeholder defined within the application's UI (in the shell or within views) into which views are displayed.</param>
|
|
/// <param name="eventAggregator">The EventAggregator which allows different components to publish/subscribe to events without being coupled to each other.</param>
|
|
/// <param name="unityContainer">The unityContainer.</param>
|
|
public ExportGraphMainViewModel(IExportGraphMainView view, IRegionManager regionManager, IEventAggregator eventAggregator, IUnityContainer unityContainer)
|
|
: base(regionManager, eventAggregator, unityContainer)
|
|
{
|
|
View = view;
|
|
View.DataContext = this;
|
|
NotificationRequest = new InteractionRequest<Notification>();
|
|
ConfirmationRequest = new InteractionRequest<Confirmation>();
|
|
|
|
_eventAggregator = eventAggregator;
|
|
_unityContainer = unityContainer;
|
|
}
|
|
|
|
#region Const
|
|
|
|
private const string testChannels = "Test Channels";
|
|
private const string EventNumber = "Event Number";
|
|
private const string calculatedChannels = "Calculated Channels";
|
|
private const string graphChannels = "Graph Channels: ";
|
|
|
|
#endregion
|
|
|
|
#region Colors
|
|
|
|
private readonly List<Color> _graphColors = new List<Color> { Colors.Transparent, Colors.Blue, Colors.Red, Colors.Green, Colors.BlueViolet, Colors.Brown, Colors.Aqua, Colors.Lime, Colors.Gray, Colors.YellowGreen, Colors.Black };
|
|
|
|
/// <summary>
|
|
/// Assign unused color to selected/locked channel
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private Color GetNextColor()
|
|
{
|
|
var nextColor = Colors.Transparent;
|
|
|
|
var channelCount = (LockedChannelList.Any() ? LockedChannelList.Count : 0) + (SelectedChannelList.Any() ? SelectedChannelList.Count : 0);
|
|
if (channelCount >= _graphColors.Count)
|
|
{
|
|
var nextColorIndex = channelCount % _graphColors.Count + 1;
|
|
if (nextColorIndex >= _graphColors.Count) { nextColorIndex = 1; }
|
|
nextColor = _graphColors[nextColorIndex];
|
|
}
|
|
else
|
|
{
|
|
var usedColors = new List<Color>();
|
|
usedColors.AddRange(LockedChannelList.Select(ch => ch.ChannelColor).ToList());
|
|
usedColors.AddRange(SelectedChannelList.Select(ch => ch.ChannelColor).ToList());
|
|
nextColor = _graphColors.Find(c1 => usedColors.TrueForAll(c2 => c2 != c1));
|
|
}
|
|
return nextColor;
|
|
}
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
public override void Initialize()
|
|
{
|
|
|
|
}
|
|
|
|
private bool _lockedOnly = false; //only published locked channels
|
|
public override void Initialize(object parameter)
|
|
{
|
|
Parent = (IBaseViewModel)parameter;
|
|
if (Parent is IPSDReportMainViewModel) { _lockedOnly = true; } // only put checked channels in the report
|
|
FilterView = GetFilterView(this);
|
|
Subscribe();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset all lists and publish changes
|
|
/// </summary>
|
|
private void CleanSelection()
|
|
{
|
|
LockedChannelList = new List<ITestChannel>();
|
|
ChannelList = new ObservableCollection<ITestChannel>();
|
|
FilteredChannelList = new ObservableCollection<ITestChannel>();
|
|
SelectedChannelList = new List<ITestChannel>();
|
|
_lastIndexChecked = 0;
|
|
_eventAggregator.GetEvent<GraphClearNotification>().Publish(new GraphClearNotificationArg { GraphClear = true, ParentVM = Parent });
|
|
|
|
PublishSelectedChannels();
|
|
|
|
SelectedGroupName = string.Empty;
|
|
GC.Collect();
|
|
}
|
|
/// <summary>
|
|
/// Format the Channel Display Name based on the isoCode setting
|
|
/// </summary>
|
|
/// <param name="channelName2"></param>
|
|
/// <param name="channelDescriptionString"></param>
|
|
/// <param name="isoCode"></param>
|
|
/// <returns></returns>
|
|
private string FormatChannelDisplayName(string channelName2, string channelDescriptionString, string isoCode)
|
|
{
|
|
return _showIsoCodes ? $"{channelName2} {channelDescriptionString} {Environment.NewLine} {isoCode}" : $"{channelName2} {channelDescriptionString}";
|
|
}
|
|
|
|
//hold onto the test summaries for reloads
|
|
private List<ITestSummary> testSummaries;
|
|
/// <summary>
|
|
/// Read all graphs, calculated channels and channels for the selected test
|
|
/// and select and display first group or channel
|
|
/// </summary>
|
|
/// <param name="list"></param>
|
|
private void OnTestSummaryChanged(TestSummaryChangeNotificationArg arg)
|
|
{
|
|
if (Parent != arg?.ParentVM) return;
|
|
|
|
//43387 Don't build the TestId tree until all of the tests have been selected
|
|
if (arg?.SummaryList.Count() != arg?.TotalSummaryCount) return;
|
|
|
|
var list = arg?.SummaryList;
|
|
testSummaries = list;
|
|
CleanSelection(); //clean every time, otherwise channels weren't being removed on test deselection
|
|
|
|
var total = 0;
|
|
//this list will hold test setups we want to remove
|
|
var listToRemove = new List<ITestSummary>();
|
|
if (list != null && list.Any())
|
|
{
|
|
foreach (var l in list)
|
|
{
|
|
//for now if there are no modules, remove the test from the list
|
|
if (l.TestMetadata == null || null == l.TestMetadata.TestRun || 0 == l.TestMetadata.TestRun.Modules.Count)
|
|
{
|
|
APILogger.Log($"Test {l.SetupName} - {l.TestMetadata.TestRun.FilePath} has no modules, skipping");
|
|
listToRemove.Add(l);
|
|
continue;
|
|
}
|
|
if (l.Channels.Any() && l.Channels.FirstOrDefault() == null)
|
|
{
|
|
// LOAD NOW!
|
|
Utils.SetChannelInfo(l.TestMetadata, Path.GetDirectoryName(l.TestMetadata.TestRun.FilePath), DTS.Serialization.SliceRaw.File.PersistentChannel.GetIsoCode);
|
|
l.Channels = l.TestMetadata.TestRun.Channels;
|
|
l.Graphs = l.TestMetadata.TestSetup.TestGraphs;
|
|
l.CalculatedChannels = l.TestMetadata.TestRun.CalculatedChannels;
|
|
}
|
|
foreach (var graph in l.Graphs)
|
|
{
|
|
//12017 Viewer shows "Graphs 1/2" when there is only 1 channel
|
|
//this issue was caused by an included graph with no channels.
|
|
if (graph.ChannelIds.Any())
|
|
{
|
|
total++;
|
|
}
|
|
}
|
|
if (null != l.CalculatedChannels)
|
|
{
|
|
total += l.CalculatedChannels.Count;
|
|
}
|
|
}
|
|
}
|
|
if (listToRemove.Any())
|
|
{
|
|
foreach( var l in listToRemove) { list?.Remove(l); }
|
|
}
|
|
if (list != null && list.Count <= 0) return;
|
|
var summaryList = list.ToList();
|
|
foreach (var ts in summaryList)
|
|
{
|
|
var testName = ts.Id + " " + ts.SetupName + " " + ts.DataType + " " + Utils.FormatTimeStamp(ts.TimeStamp);
|
|
|
|
if (ts.Graphs.Count > 0)
|
|
{
|
|
foreach (var graph in ts.Graphs)
|
|
{
|
|
foreach (var gch in graph.Channels.OrderBy(gch => gch.AbsoluteDisplayOrder).ThenBy(gch => gch.Number))
|
|
{
|
|
if (ChannelList.Any(x => x.Equals(gch))) continue;
|
|
|
|
gch.Group = testName;
|
|
gch.SubGroup = graphChannels + graph.Name;
|
|
gch.IsGraphChannel = true;
|
|
gch.GraphName = graph.Name;
|
|
gch.ChannelDisplayName = gch.ChannelName2 + " " + gch.ChannelDescriptionString;
|
|
gch.Parent = this;
|
|
gch.ChannelColor = Colors.Transparent;
|
|
gch.CanSelectChannel = false; gch.IsSelected = false; gch.IsLocked = false; gch.CanSelectChannel = true;
|
|
//Select first group
|
|
if (ChannelList.Count == 0) { SelectedGroupName = gch.SubGroup.Trim(); }
|
|
ChannelList.Add(gch);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((ts.CalculatedChannels != null) && (ts.CalculatedChannels.Count > 0))
|
|
{
|
|
foreach (var cch in ts.CalculatedChannels.OrderBy(cch => cch.AbsoluteDisplayOrder).ThenBy(cch => cch.Number))
|
|
{
|
|
if (ChannelList.Any(x => x.Equals(cch))) continue;
|
|
|
|
cch.Group = testName;
|
|
cch.SubGroup = calculatedChannels;
|
|
cch.IsGraphChannel = false;
|
|
cch.GraphName = string.Empty;
|
|
cch.ChannelDisplayName = cch.ChannelName2 + " " + cch.ChannelDescriptionString;
|
|
cch.IsCalculatedChannel = true;
|
|
cch.Parent = this;
|
|
cch.ChannelColor = Colors.Transparent;
|
|
cch.CanSelectChannel = false; cch.IsSelected = false; cch.IsLocked = false; cch.CanSelectChannel = true;
|
|
//Or select first calculated channel
|
|
if (ChannelList.Count == 0) { cch.IsSelected = true; }
|
|
ChannelList.Add(cch);
|
|
}
|
|
}
|
|
if (ts.Channels.Count > 0)
|
|
{
|
|
var tsChannels = ts.Channels.OrderBy(ch => ch.AbsoluteDisplayOrder).ThenBy(ch => ch.Number).ToList();
|
|
for (int i = 0; i < tsChannels.Count - 1; i++)
|
|
{
|
|
if (tsChannels[i].AbsoluteDisplayOrder == tsChannels[i + 1].AbsoluteDisplayOrder &&
|
|
tsChannels[i].Number == tsChannels[i + 1].Number)
|
|
{
|
|
switch (calibrationBehaviorSetting)
|
|
{
|
|
case CalibrationBehaviors.LinearIfAvailable:
|
|
tsChannels.RemoveAt(i);
|
|
i--;
|
|
break;
|
|
case CalibrationBehaviors.NonLinearIfAvailable:
|
|
tsChannels.RemoveAt(i + 1);
|
|
break;
|
|
case CalibrationBehaviors.UseBothIfAvailable:
|
|
tsChannels[i].ChannelDescriptionString += " (NonLinear)";
|
|
tsChannels[i + 1].ChannelDescriptionString += " (Linear)";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
total += tsChannels.Count;
|
|
foreach (var ch in tsChannels)
|
|
{
|
|
if (ChannelList.Any(x => x.Equals(ch))) continue;
|
|
|
|
ch.Group = testName;
|
|
ch.SubGroup = testChannels;
|
|
ch.IsGraphChannel = false;
|
|
ch.GraphName = string.Empty;
|
|
var channelDescription = ch.ChannelDescriptionString;
|
|
if (SensorConstants.IsTestSpecificEmbedded(channelDescription))
|
|
{
|
|
channelDescription = Strings.Table_NA;
|
|
}
|
|
ch.ChannelDisplayName = FormatChannelDisplayName(ch.ChannelName2, channelDescription, ch.IsoCode);
|
|
ch.Parent = this;
|
|
ch.ChannelColor = Colors.Transparent;
|
|
ch.CanSelectChannel = false; ch.IsSelected = false; ch.IsLocked = false; ch.CanSelectChannel = true;
|
|
//Or select first channel
|
|
if (ChannelList.Count == 0) { ch.IsSelected = true; }
|
|
ChannelList.Add(ch);
|
|
}
|
|
}
|
|
}
|
|
ChannelList.CollectionChanged += GraphList_CollectionChanged;
|
|
FilteredChannelList = new ObservableCollection<ITestChannel>(ChannelList);
|
|
TestChannelsTree.CollectionChanged += TestChannelsTree_CollectionChanged;
|
|
_eventAggregator.GetEvent<GraphLoadedCountNotification>().Publish(new GraphLoadedCountNotificationArg { LoadedCount = total, ParentVM = Parent });
|
|
|
|
if (ChannelList.Any())
|
|
{
|
|
var treeChannels = ChannelList.ToList();
|
|
TestChannelsTree = GetTestChannelsTree(treeChannels);
|
|
TestIdsTree = GetTestIdsTree(TestChannelsTree, summaryList);
|
|
|
|
foreach (var treeViewChannels in TestChannelsTree)
|
|
{
|
|
treeViewChannels.IsExpanded = false;
|
|
}
|
|
//temp
|
|
var parent = TestChannelsTree?.FirstOrDefault()?.Groups?.FirstOrDefault()?.Parent;
|
|
foreach (var testId in TestIdsTree)
|
|
{
|
|
testId.Parent = parent;
|
|
foreach (var group in testId.Events)
|
|
{
|
|
group.Parent = parent;
|
|
}
|
|
}
|
|
|
|
|
|
if (!string.IsNullOrEmpty(SelectedGroupName))
|
|
{
|
|
var group = (from t in TestChannelsTree from g in t.Groups where g.Name == SelectedGroupName.Replace(graphChannels, string.Empty) select g).FirstOrDefault();
|
|
if (group != null) { AddSelectedGroup(group); }
|
|
}
|
|
}
|
|
IsFilterEnabled = _channelList.Count > 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check changes to Test Modifications to see whether we need to withhold user input
|
|
/// </summary>
|
|
private void OnTestModificationsChanged(ITestModificationModel testModificationModel)
|
|
{
|
|
if (testModificationModel != null)
|
|
{
|
|
TestModified = testModificationModel.IsModified;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subscribe for events
|
|
/// </summary>
|
|
private void Subscribe()
|
|
{
|
|
_eventAggregator.GetEvent<RaiseNotification>().Subscribe(OnRaiseNotification);
|
|
_eventAggregator.GetEvent<FilterParameterChangedEvent>().Subscribe(OnFilterChanged);
|
|
_eventAggregator.GetEvent<TestSummaryChangeNotification>().Subscribe(OnTestSummaryChanged);
|
|
_eventAggregator.GetEvent<TestModificationChangedEvent>().Subscribe(OnTestModificationsChanged);
|
|
_eventAggregator.GetEvent<ExportCalibrationBehaviorSettingChangedEvent>().Subscribe(OnCalibrationBehaviorSettingChanged);
|
|
_eventAggregator.GetEvent<CalibrationBehaviorSettableInViewerChangedEvent>().Subscribe(OnCalibrationBehaviorSettableInViewerChanged);
|
|
_eventAggregator.GetEvent<ChannelCodesViewChangedEvent>().Subscribe(OnChannelCodesViewChangedEvent);
|
|
_eventAggregator.GetEvent<ClearSelectedExportsEvent>().Subscribe(OnClearSelectedExports);
|
|
}
|
|
|
|
|
|
private void OnCalibrationBehaviorSettableInViewerChanged(bool cbSettable)
|
|
{
|
|
|
|
}
|
|
|
|
private void OnChannelCodesViewChangedEvent(DTS.Common.Enums.IsoViewMode viewMode) => _showIsoCodes = (viewMode == Common.Enums.IsoViewMode.ISOAndUserCode
|
|
|| viewMode == Common.Enums.IsoViewMode.ISOOnly);
|
|
|
|
private CalibrationBehaviors calibrationBehaviorSetting { get; set; } = CalibrationBehaviors.NonLinearIfAvailable;
|
|
private void OnCalibrationBehaviorSettingChanged(CalibrationBehaviors cb)
|
|
{
|
|
calibrationBehaviorSetting = cb;
|
|
if (null != testSummaries)
|
|
{
|
|
OnTestSummaryChanged(new TestSummaryChangeNotificationArg { SummaryList = testSummaries, ParentVM = Parent });
|
|
}
|
|
}
|
|
|
|
#region Filter
|
|
|
|
/// <summary>
|
|
/// Filter Data Event
|
|
/// </summary>
|
|
/// <param name="args">Filter value</param>
|
|
public void OnFilterChanged(FilterParameterArgs args)
|
|
{
|
|
if (((IFilterViewModel)FilterView.DataContext).Parent == this)
|
|
{
|
|
FilteredTestIdsTree = string.IsNullOrEmpty(args.Param) ? new ObservableCollection<TreeViewIds>(TestIdsTree)
|
|
: new ObservableCollection<TreeViewIds>((from x in TestIdsTree where x.Name.ToLower().Contains(args.Param.ToLower()) select x).ToList());
|
|
}
|
|
}
|
|
|
|
#endregion Filter
|
|
|
|
#region Override
|
|
|
|
/// <summary>
|
|
/// Private Event handler for RaiseNotification event.
|
|
/// </summary>
|
|
private void OnRaiseNotification(NotificationContentEventArgs eventArgsWithTitle)
|
|
{
|
|
// Notification object expects a NotificationContentEventArgsWithoutTitle object and a Title string.
|
|
var eventArgsWithoutTitle = new NotificationContentEventArgs(eventArgsWithTitle.Message, eventArgsWithTitle.MessageDetails, eventArgsWithTitle.Image);
|
|
|
|
NotificationRequest.Raise(new Notification
|
|
{
|
|
Content = eventArgsWithoutTitle,
|
|
Title = eventArgsWithTitle.Title
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// ? I thik it's not beed used
|
|
/// </summary>
|
|
public override void Activated()
|
|
{
|
|
var fp = new FilterParameterArgs
|
|
{
|
|
Param = string.Empty,
|
|
Requester = this
|
|
};
|
|
_eventAggregator.GetEvent<FilterParameterChangedEvent>().Publish(fp);
|
|
}
|
|
|
|
#endregion Override
|
|
|
|
/// <summary>
|
|
/// Publish Locked Channels
|
|
/// </summary>
|
|
|
|
|
|
/// <summary>
|
|
/// Publish Selected and/or locked Channels
|
|
/// </summary>
|
|
public void PublishSelectedChannels()
|
|
{
|
|
var list = new List<ITestChannel>();
|
|
if (LockedChannelList.Any()) list.AddRange(LockedChannelList);
|
|
if (!_lockedOnly && SelectedChannelList.Any()) list.AddRange(SelectedChannelList);
|
|
var count = list.Count;
|
|
_eventAggregator.GetEvent<GraphSelectedChannelCountNotification>().Publish(new GraphSelectedChannelCountNotificationArg { SelectedChannelCount = count, ParentVM = Parent });
|
|
_eventAggregator.GetEvent<GraphSelectedChannelsNotification>().Publish(new GraphSelectedChannelsNotificationArg { SelectedChannels = list, ParentVM = Parent });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Publish Selected and/or locked Events
|
|
/// </summary>
|
|
public void PublishSelectedEvents()
|
|
{
|
|
var list = new BindingList<ITestEvent>();
|
|
if (!_lockedOnly && SelectedEventList.Any())
|
|
{
|
|
foreach (var sel in SelectedEventList)
|
|
{
|
|
list.Add(sel);
|
|
}
|
|
}
|
|
var count = list.Count;
|
|
_eventAggregator.GetEvent<GraphSelectedEventCountNotification>().Publish(new GraphSelectedEventCountNotificationArg { SelectedEventCount = count, ParentVM = Parent });
|
|
_eventAggregator.GetEvent<GraphSelectedEventsNotification>().Publish(new GraphSelectedEventsNotificationArg { SelectedEvents = list, ParentVM = Parent });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load Filter View
|
|
/// </summary>
|
|
/// <param name="parent"></param>
|
|
/// <returns></returns>
|
|
private IFilterView GetFilterView(IBaseViewModel parent)
|
|
{
|
|
var view = _unityContainer.Resolve<IFilterView>();
|
|
var viewModel = _unityContainer.Resolve<IFilterViewModel>();
|
|
view.DataContext = viewModel;
|
|
viewModel.Initialize(parent);
|
|
return view;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Reset Functions
|
|
|
|
private void ResetSelectedChannelColor()
|
|
{
|
|
foreach (var ch in SelectedChannelList) { if (ch.IsLocked) continue; ch.ChannelColor = Colors.Transparent; ch.CanSelectChannel = true; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset all selected channels prior to selecting new channel or group
|
|
/// </summary>
|
|
private void ResetSelected() { ResetSelected(string.Empty); }
|
|
private void ResetSelected(string eventName)
|
|
{
|
|
foreach (var test in TestIdsTree)
|
|
{
|
|
foreach (var e in test.Events)
|
|
{
|
|
if (!string.IsNullOrEmpty(eventName) && e.Name == eventName) continue;
|
|
|
|
e.IsSelected = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Reset Functions
|
|
|
|
#region Add Selected/Locked Channel
|
|
|
|
#region Locked Channel
|
|
public void AddLockedGroupChannels(string testName, string groupName, List<ITestChannel> channels, bool isLocked)
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
foreach (var channel in channels)
|
|
{
|
|
if (isLocked)
|
|
{
|
|
if (SelectedChannelList.Contains(channel)) { SelectedChannelList.Remove(channel); }
|
|
|
|
if (LockedChannelList.Contains(channel)) continue;
|
|
channel.CanSelectChannel = false;
|
|
channel.IsLocked = true;
|
|
channel.CanSelectChannel = true;
|
|
LockedChannelList.Add(channel);
|
|
if (channel.ChannelColor == Colors.Transparent) { channel.ChannelColor = GetNextColor(); }
|
|
}
|
|
else
|
|
{
|
|
if (!LockedChannelList.Contains(channel)) continue;
|
|
LockedChannelList.Remove(channel);
|
|
}
|
|
}
|
|
PublishSelectedChannels();
|
|
|
|
if (!LockedChannelList.Any() && !SelectedChannelList.Any())
|
|
{
|
|
var group = (from t in TestChannelsTree from g in t.Groups where g.TestName == testName && g.Name == groupName select g).FirstOrDefault();
|
|
if (group != null) { group.IsSelected = true; }
|
|
}
|
|
else { if (SelectedChannelList.Any()) { PublishSelectedChannels(); } }
|
|
|
|
UpdateChannelLocks();
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
public void AddLockedChannel(ITestChannel channel, bool isLocked)
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
|
|
if (isLocked)
|
|
{
|
|
if (SelectedChannelList.Contains(channel)) { SelectedChannelList.Remove(channel); }
|
|
|
|
if (!LockedChannelList.Contains(channel))
|
|
{
|
|
channel.CanSelectChannel = false;
|
|
channel.IsLocked = true;
|
|
channel.CanSelectChannel = true;
|
|
LockedChannelList.Add(channel);
|
|
if (channel.ChannelColor == Colors.Transparent) { channel.ChannelColor = GetNextColor(); }
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LockedChannelList.Contains(channel))
|
|
{
|
|
LockedChannelList.Remove(channel);
|
|
}
|
|
// if there are no selected or locked channels add unlocked channel to selected list
|
|
if (!SelectedChannelList.Any())
|
|
{
|
|
if (!LockedChannelList.Exists(x => x.IsSelected)) { AddSelectedChannel(channel, true); }
|
|
}
|
|
}
|
|
|
|
UpdateChannelLocks();
|
|
|
|
PublishSelectedChannels();
|
|
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
private const int MAX_LOCKED_CHANNELS = 8;
|
|
|
|
private void UpdateChannelLocks()
|
|
{
|
|
var canLock = LockedChannelList.Count < MAX_LOCKED_CHANNELS;
|
|
foreach (var treeChannel in TestChannelsTree)
|
|
{
|
|
foreach (var group in treeChannel.Groups)
|
|
{
|
|
|
|
if (group.IsGraph)
|
|
{
|
|
if (group.IsLocked)
|
|
{
|
|
continue;
|
|
}
|
|
group.CanLock = group.Channels.Count + LockedChannelList.Count <= MAX_LOCKED_CHANNELS;
|
|
}
|
|
|
|
foreach (var channel in group.Channels)
|
|
{
|
|
if (channel.IsLocked) { continue; }
|
|
channel.CanLock = canLock;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion Locked Channel
|
|
|
|
#region Selected Channel
|
|
public void AddSelectedGroupChannels(string groupName, List<ITestChannel> channels)
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
ResetSelectedChannelColor();
|
|
ResetSelected(groupName);
|
|
|
|
SelectedChannelList = new List<ITestChannel>();
|
|
foreach (var channel in channels)
|
|
{
|
|
SelectedChannelList.Add(channel);
|
|
if (channel.ChannelColor == Colors.Transparent) { channel.ChannelColor = GetNextColor(); }
|
|
}
|
|
|
|
PublishSelectedChannels();
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
public void AddSelectedGroup(TestGroup group)
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
group.IsSelected = true;
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add selected channel to the list or select a group (graph) of channels
|
|
/// </summary>
|
|
/// <param name="channel"></param>
|
|
/// <param name="reset"></param>
|
|
public void AddSelectedChannel(ITestChannel channel, bool reset)
|
|
{
|
|
if (channel.IsLocked && LockedChannelList.Contains(channel))
|
|
{
|
|
ResetSelectedChannelColor();
|
|
SelectedChannelList = new List<ITestChannel>();
|
|
PublishSelectedChannels();
|
|
return;
|
|
}
|
|
|
|
if (channel.IsSelected && SelectedChannelList.Contains(channel)) return;
|
|
|
|
if (channel.IsGraphChannel)
|
|
{
|
|
var group = (from t in TestChannelsTree from g in t.Groups where g.TestName == channel.Group && g.Name == channel.GraphName select g).FirstOrDefault();
|
|
if (group != null) { AddSelectedGroup(group); }
|
|
}
|
|
else
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
if (reset)
|
|
{
|
|
SelectedChannelList = new List<ITestChannel>();
|
|
ResetSelected();
|
|
SelectedGroupName = string.Empty;
|
|
}
|
|
SelectedChannelList.Add(channel);
|
|
|
|
if (channel.ChannelColor == Colors.Transparent) { channel.ChannelColor = GetNextColor(); }
|
|
PublishSelectedChannels();
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
|
|
}
|
|
public void AddSelectedChannel(ITestChannel channel)
|
|
{
|
|
if (channel.IsLocked && LockedChannelList.Contains(channel))
|
|
{
|
|
//ResetSelected();
|
|
SelectedChannelList = new List<ITestChannel>();
|
|
PublishSelectedChannels();
|
|
return;
|
|
}
|
|
|
|
if (channel.IsSelected && SelectedChannelList.Contains(channel)) return;
|
|
|
|
|
|
if (channel.IsGraphChannel)
|
|
{
|
|
var group = (from t in TestChannelsTree from g in t.Groups where g.TestName == channel.Group && g.Name == channel.GraphName select g).FirstOrDefault();
|
|
if (group != null) { AddSelectedGroup(group); }
|
|
}
|
|
else
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
SelectedChannelList = new List<ITestChannel>();
|
|
ResetSelected();
|
|
SelectedGroupName = string.Empty;
|
|
SelectedChannelList.Add(channel);
|
|
|
|
if (channel.ChannelColor == Colors.Transparent) { channel.ChannelColor = GetNextColor(); }
|
|
PublishSelectedChannels();
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
|
|
}
|
|
#endregion Selected Channel
|
|
|
|
#region Locked Event
|
|
public void AddLockedEvents(string testName, string groupName, List<ITestEvent> events, bool isLocked)
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
foreach (var evnt in events)
|
|
{
|
|
if (isLocked)
|
|
{
|
|
if (SelectedEventList.Contains(evnt)) { SelectedEventList.Remove(evnt); }
|
|
|
|
if (LockedEventList.Contains(evnt)) continue;
|
|
//evnt.CanSelectEvent = false;
|
|
evnt.IsLocked = true;
|
|
//evnt.CanSelectEvent = true;
|
|
LockedEventList.Add(evnt);
|
|
//if (evnt.EventColor == Colors.Transparent) { evnt.EventColor = GetNextColor(); }
|
|
}
|
|
else
|
|
{
|
|
if (!LockedEventList.Contains(evnt)) continue;
|
|
LockedEventList.Remove(evnt);
|
|
}
|
|
}
|
|
PublishSelectedEvents();
|
|
|
|
if (!LockedEventList.Any() && !SelectedEventList.Any())
|
|
{
|
|
var group = (from t in TestChannelsTree from g in t.Groups where g.TestName == testName && g.Name == groupName select g).FirstOrDefault();
|
|
if (group != null) { group.IsSelected = true; }
|
|
}
|
|
else { if (SelectedEventList.Any()) { PublishSelectedEvents(); } }
|
|
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
|
|
#endregion Locked Event
|
|
|
|
#region Id Event
|
|
private void OnClearSelectedExports(ClearSelectedExportsArg arg)
|
|
{
|
|
SelectedEventList.Clear();
|
|
}
|
|
public void AddToSelectedEvents(string groupName, List<ITestEvent> events)
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
foreach (var e in events)
|
|
{
|
|
if (!SelectedEventList.Exists(item => item.TestItem == e.TestItem && item.Name == e.Name))
|
|
{
|
|
SelectedEventList.Add(e);
|
|
}
|
|
}
|
|
|
|
PublishSelectedEvents();
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
public void RemoveFromSelectedEvents(string groupName, List<ITestEvent> events)
|
|
{
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(true);
|
|
foreach (var e in events)
|
|
{
|
|
var match = SelectedEventList.Find(item => item.TestItem == e.TestItem && item.Name == e.Name);
|
|
if (null != match)
|
|
{
|
|
SelectedEventList.Remove(match);
|
|
}
|
|
}
|
|
|
|
PublishSelectedEvents();
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>().Publish(false);
|
|
}
|
|
public void SetItemsBetween(int startTreeIndex, int endTreeIndex)
|
|
{
|
|
foreach (var testId in TestIdsTree)
|
|
{
|
|
foreach (var e in testId.Events)
|
|
{
|
|
if (((e.TreeIndex >= startTreeIndex) && (e.TreeIndex <= endTreeIndex)) ||
|
|
((e.TreeIndex <= startTreeIndex) && (e.TreeIndex >= endTreeIndex)))
|
|
{
|
|
e.IsSelected = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void ResetAllItems()
|
|
{
|
|
foreach (var testId in TestIdsTree)
|
|
{
|
|
foreach (var e in testId.Events)
|
|
{
|
|
//Don't bother setting it to False if it is already
|
|
if (e.IsSelected)
|
|
{
|
|
e.IsSelected = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void SetLastIndexChecked(int index)
|
|
{
|
|
_lastIndexChecked = index;
|
|
}
|
|
|
|
#endregion Id Event
|
|
#endregion Add Selected/Locked Channel
|
|
|
|
#region ContextRegion
|
|
|
|
public object ContextGraphMainRegion
|
|
{
|
|
get => ((ExportGraphMainView)View).GraphMainRegion.DataContext;
|
|
set { ((ExportGraphMainView)View).GraphMainRegion.DataContext = value; OnPropertyChanged("ContextGraphMainRegion"); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
private bool _isFilterEnabled = false;
|
|
|
|
public bool IsFilterEnabled
|
|
{
|
|
get => _isFilterEnabled;
|
|
set { _isFilterEnabled = value; OnPropertyChanged("IsFilterEnabled"); }
|
|
}
|
|
|
|
#region Selected/Locked Group
|
|
|
|
private string _selectedGroupName = string.Empty;
|
|
|
|
public string SelectedGroupName
|
|
{
|
|
get => _selectedGroupName;
|
|
set { _selectedGroupName = value; OnPropertyChanged("SelectedGroupName"); }
|
|
}
|
|
|
|
private string _lockedGroupName = string.Empty;
|
|
public string LockedGroupName
|
|
{
|
|
get => _lockedGroupName;
|
|
set { _lockedGroupName = value; OnPropertyChanged("LockedGroupName"); }
|
|
}
|
|
#endregion Selected/Locked Group
|
|
|
|
#region Lists
|
|
private List<ITestChannel> _lockedChannelList = new List<ITestChannel>();
|
|
|
|
public List<ITestChannel> LockedChannelList
|
|
{
|
|
get => _lockedChannelList;
|
|
set { _lockedChannelList = value; OnPropertyChanged("LockedChannelList"); }
|
|
}
|
|
|
|
private List<ITestEvent> _lockedEventList = new List<ITestEvent>();
|
|
|
|
public List<ITestEvent> LockedEventList
|
|
{
|
|
get => _lockedEventList;
|
|
set { _lockedEventList = value; OnPropertyChanged("LockedEventList"); }
|
|
}
|
|
|
|
private List<ITestChannel> _selectedChannelList = new List<ITestChannel>();
|
|
|
|
public List<ITestChannel> SelectedChannelList
|
|
{
|
|
get => _selectedChannelList;
|
|
set { _selectedChannelList = value; OnPropertyChanged("SelectedChannelList"); }
|
|
}
|
|
|
|
private List<ITestEvent> _selectedEventList = new List<ITestEvent>();
|
|
|
|
public List<ITestEvent> SelectedEventList
|
|
{
|
|
get => _selectedEventList;
|
|
set { _selectedEventList = value; OnPropertyChanged("SelectedEventList"); }
|
|
}
|
|
|
|
private int _lastIndexChecked = 0;
|
|
public int LastIndexChecked
|
|
{
|
|
get
|
|
{
|
|
return _lastIndexChecked;
|
|
}
|
|
}
|
|
|
|
#endregion Lists
|
|
|
|
#region ObservableCollection
|
|
private ObservableCollection<ITestChannel> _channelList = new ObservableCollection<ITestChannel>();
|
|
public ObservableCollection<ITestChannel> ChannelList
|
|
{
|
|
get => _channelList;
|
|
set { _channelList = value; IsFilterEnabled = _channelList.Count > 0; FilteredChannelList = new ObservableCollection<ITestChannel>(_channelList); OnPropertyChanged("ChannelList"); }
|
|
}
|
|
private ObservableCollection<ITestChannel> _filteredChannelList = new ObservableCollection<ITestChannel>();
|
|
|
|
public ObservableCollection<ITestChannel> FilteredChannelList
|
|
{
|
|
get => _filteredChannelList;
|
|
set { _filteredChannelList = value; TestChannelsTree = GetTestChannelsTree(_filteredChannelList.ToList()); OnPropertyChanged("FilteredChannelList"); }
|
|
}
|
|
|
|
private ObservableCollection<TreeViewChannels> _testChannelsTree = new ObservableCollection<TreeViewChannels>();
|
|
|
|
/// <summary>
|
|
/// Main treeview object
|
|
/// </summary>
|
|
public ObservableCollection<TreeViewChannels> TestChannelsTree
|
|
{
|
|
get => _testChannelsTree;
|
|
set { _testChannelsTree = value; OnPropertyChanged("TestChannelsTree"); }
|
|
}
|
|
|
|
private ObservableCollection<TreeViewIds> _testIdsTree = new ObservableCollection<TreeViewIds>();
|
|
|
|
/// <summary>
|
|
/// Main treeview object
|
|
/// </summary>
|
|
public ObservableCollection<TreeViewIds> TestIdsTree
|
|
{
|
|
get => _testIdsTree;
|
|
set { _testIdsTree = value; FilteredTestIdsTree = _testIdsTree; OnPropertyChanged("TestIdsTree"); }
|
|
}
|
|
|
|
private ObservableCollection<TreeViewIds> _filteredTestIdsTree = new ObservableCollection<TreeViewIds>();
|
|
|
|
public ObservableCollection<TreeViewIds> FilteredTestIdsTree
|
|
{
|
|
get => _filteredTestIdsTree;
|
|
set { _filteredTestIdsTree = value; OnPropertyChanged("FilteredTestIdsTree"); }
|
|
}
|
|
#endregion ObservableCollection
|
|
|
|
#region ObservableCollection Extension
|
|
public void TestChannelsTree_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
if (e.OldItems != null) { foreach (INotifyPropertyChanged item in e.OldItems) item.PropertyChanged -= TestChannelsTree_PropertyChanged; }
|
|
if (e.NewItems != null) { foreach (INotifyPropertyChanged item in e.NewItems) { item.PropertyChanged += TestChannelsTree_PropertyChanged; } }
|
|
}
|
|
|
|
private void TestChannelsTree_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
if (e.PropertyName != "TestChannelsTree") { }
|
|
}
|
|
|
|
public void GraphList_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
if (e.OldItems != null) { foreach (INotifyPropertyChanged item in e.OldItems) item.PropertyChanged -= GraphList_PropertyChanged; }
|
|
if (e.NewItems != null) { foreach (INotifyPropertyChanged item in e.NewItems) { item.PropertyChanged += GraphList_PropertyChanged; } }
|
|
}
|
|
|
|
private void GraphList_PropertyChanged(object sender, PropertyChangedEventArgs e) { if (e.PropertyName != "ChannelList") { } }
|
|
|
|
#endregion ObservableCollection Extension
|
|
|
|
#region PropertyChanged
|
|
///<summary>
|
|
///Occurs when a property value changes.
|
|
///</summary>
|
|
public new event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
private new void OnPropertyChanged(string propertyName) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); }
|
|
#endregion PropertyChanged
|
|
|
|
/// <summary>
|
|
/// Gets the HeaderInfo.
|
|
/// </summary>
|
|
public string HeaderInfo => "GraphRegion";
|
|
|
|
public new bool IsBusy { get; set; }
|
|
|
|
public new bool IsDirty { get; set; }
|
|
|
|
private bool _testModified = false;
|
|
public bool TestModified { get => _testModified; set { _testModified = value; OnPropertyChanged("TestModified"); } }
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Build the tree form list
|
|
/// </summary>
|
|
/// <param name="list">Test Channel list</param>
|
|
/// <returns>tree</returns>
|
|
private ObservableCollection<TreeViewChannels> GetTestChannelsTree(List<ITestChannel> list)
|
|
{
|
|
if (!list.Any()) return new ObservableCollection<TreeViewChannels>();
|
|
|
|
var result = (from t in list
|
|
group t.TestSetupName by t.Group into test
|
|
select new TreeViewChannels
|
|
{
|
|
Name = test.Key,
|
|
Groups = new ObservableCollection<TestGroup>(from t in list
|
|
where t.Group == test.Key
|
|
group t.Group by t.SubGroup into g
|
|
select new TestGroup
|
|
{
|
|
TestName = test.Key,
|
|
DisplayName = g.Key + " [ " + list.Count(ch => ch.Group == test.Key && ch.SubGroup == g.Key) + " Channels]",
|
|
Path = test.Key + "|" + g.Key + " [ " + list.Count(ch => ch.Group == test.Key && ch.SubGroup == g.Key) + " Channels]",
|
|
Name = g.Key.Replace(graphChannels, string.Empty),
|
|
IsGraph = g.Key.StartsWith("Graph"),
|
|
Channels = new ObservableCollection<ITestChannel>(list.Where(ch => ch.Group == test.Key && ch.SubGroup == g.Key).OrderBy(ch => ch.AbsoluteDisplayOrder).ThenBy(ch => ch.Number)),
|
|
Parent = this
|
|
})
|
|
|
|
}).ToList();
|
|
|
|
foreach (var tvc in result)
|
|
{
|
|
foreach (var g in tvc.Groups)
|
|
{
|
|
g.DTSFile = $"{g.Channels[0].BinaryFilePath}\\{g.Channels[0].TestId}.dts";
|
|
}
|
|
}
|
|
|
|
return new ObservableCollection<TreeViewChannels>(result);
|
|
}
|
|
|
|
private ObservableCollection<TreeViewIds> GetTestIdsTree(ObservableCollection<TreeViewChannels> treeViewChannelsList, List<ITestSummary> summaryList)
|
|
{
|
|
if (!treeViewChannelsList.Any()) return new ObservableCollection<TreeViewIds>();
|
|
|
|
var result = new ObservableCollection<TreeViewIds>();
|
|
|
|
var orderedTreeViewChannelsList = treeViewChannelsList.OrderBy(c => c.Name);
|
|
var treeIndex = 0;
|
|
double eventLength = 0;
|
|
foreach (var testId in orderedTreeViewChannelsList)
|
|
{
|
|
var testIdEnd = testId.Name.LastIndexOf(EventNumber) - 1;
|
|
var testIdName = testId.Name.Substring(0, testIdEnd);
|
|
|
|
//See if we already have an event with this TestId
|
|
var testIdFound = false;
|
|
foreach (var element in result)
|
|
{
|
|
if ((element.Events[0].TestId == testIdName))
|
|
{
|
|
testIdFound = true;
|
|
AddEvent(testId, element, treeIndex, eventLength);
|
|
treeIndex++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!testIdFound)
|
|
{
|
|
var tvi = new TreeViewIds();
|
|
tvi.TreeIndex = treeIndex;
|
|
treeIndex++;
|
|
var numEvents = orderedTreeViewChannelsList.Count(n => (n.Name.LastIndexOf(EventNumber) - 1 == testIdName.Length) && n.Name.StartsWith(testIdName));
|
|
tvi.Name = $"{testIdName} ({numEvents} events)";
|
|
|
|
//This is a new TestId, so re-calculate the event length
|
|
eventLength = CalculateEventLength(testIdName, summaryList);
|
|
AddEvent(testId, tvi, treeIndex, eventLength);
|
|
treeIndex++;
|
|
result.Add(tvi);
|
|
tvi.IsExpanded = false;
|
|
}
|
|
}
|
|
|
|
return new ObservableCollection<TreeViewIds>(result);
|
|
}
|
|
private static double CalculateEventLength(string testIdName, List<ITestSummary> summaryList)
|
|
{
|
|
double eventLength = 0.0D;
|
|
try
|
|
{
|
|
var testMetaData = summaryList.Where(t => t.Id.StartsWith(testIdName));
|
|
if (null == testMetaData) { return eventLength; }
|
|
var meta = testMetaData.FirstOrDefault();
|
|
if (null == meta ||
|
|
null == meta.TestMetadata ||
|
|
null == meta.TestMetadata.TestRun ||
|
|
null == meta.TestMetadata.TestRun.Modules ||
|
|
0 == meta.TestMetadata.TestRun.Modules.Count) { return eventLength; }
|
|
|
|
var module = testMetaData.FirstOrDefault().TestMetadata.TestRun.Modules[0];
|
|
double numberOfSamplesStr = module.NumberOfSamples;
|
|
double samplesPerSecondStr = module.SampleRateHz;
|
|
if (samplesPerSecondStr.Equals(0D)) { return eventLength; }
|
|
eventLength = Convert.ToDouble(numberOfSamplesStr) / Convert.ToDouble(samplesPerSecondStr);
|
|
}
|
|
catch( Exception ex)
|
|
{
|
|
APILogger.Log(ex);
|
|
}
|
|
return eventLength;
|
|
}
|
|
|
|
private static string ParseTestSetupName(string name)
|
|
{
|
|
var result = string.Empty;
|
|
|
|
var splitUpName = name.Split(' ');
|
|
var index = 0;
|
|
foreach (var word in splitUpName)
|
|
{
|
|
if (word == "ROI" || word == "ALL")
|
|
{
|
|
result = splitUpName[index - 1]; //It's the one before ROI or ALL
|
|
}
|
|
index++;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
private string ParseROIOrAll(string name)
|
|
{
|
|
var result = string.Empty;
|
|
|
|
var splitUpName = name.Split(' ');
|
|
foreach (var word in splitUpName)
|
|
{
|
|
if (word == "ROI" || word == "ALL")
|
|
{
|
|
result = word;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
private static string ParseTestId(string name)
|
|
{
|
|
var result = string.Empty;
|
|
|
|
var testIdLength = name.IndexOf(Constants.EventNumber);
|
|
result = name.Substring(0, testIdLength);
|
|
|
|
return result;
|
|
}
|
|
private void AddEvent(TreeViewChannels testId, TreeViewIds tvi, int treeIndex, double eventLength)
|
|
{
|
|
foreach (var group in testId.Groups)
|
|
{
|
|
var e = new TestEvent();
|
|
e.TreeIndex = treeIndex;
|
|
var eventNumberStart = testId.Name.IndexOf(EventNumber);
|
|
var actualEventNumberStart = eventNumberStart + EventNumber.Length + 1;
|
|
var actualEventNumberEnd = 0;
|
|
actualEventNumberEnd = testId.Name.IndexOf(' ', actualEventNumberStart); //Look for space after "Event Number 0001" (TSR AIR Go)
|
|
var actualEventNumberLength = actualEventNumberEnd - actualEventNumberStart;
|
|
var eventLengthStr = new DateTime(TimeSpan.FromSeconds(eventLength).Ticks).ToString("HH:mm:ss.fff");
|
|
e.Name = $"{testId.Name.Substring(eventNumberStart, EventNumber.Length + 1 + actualEventNumberLength)} {eventLengthStr}";
|
|
e.TestId = ParseTestId(testId.Name);
|
|
e.TestSetupName = ParseTestSetupName(testId.Name);
|
|
e.DataType = ParseROIOrAll(testId.Name);
|
|
var roiSuffixString = string.Empty;
|
|
e.TestItem = $"{e.TestSetupName}:{ e.TestId}:({e.DataType}){roiSuffixString}";
|
|
e.DTSFile = group.DTSFile;
|
|
e.IsExpanded = false;
|
|
tvi.Events.Add(e);
|
|
}
|
|
}
|
|
|
|
#region Commands
|
|
|
|
#endregion Commands
|
|
}
|
|
}
|