623 lines
25 KiB
C#
623 lines
25 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Composition;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Data;
|
|
using DTS.Common.Events;
|
|
using DTS.Common.Events.TTSImport;
|
|
using DTS.Common.Interface.DataRecorders;
|
|
using DTS.Common.Interface.TestSetups.Imports.TTS;
|
|
using DTS.Common.Interface.TestSetups.Imports.TTS.ReadFile;
|
|
using DTS.Common.Utilities.Logging;
|
|
using TTSImport.Resources;
|
|
using Application = System.Windows.Application;
|
|
using DASChannel = TTSImport.Model.DASChannel;
|
|
using MessageBox = System.Windows.MessageBox;
|
|
using DTS.Common.DAS.Concepts;
|
|
using DTS.Common.Enums;
|
|
using TTSImport.Model;
|
|
using Prism.Events;
|
|
using Unity;
|
|
using DTS.Common.Interactivity;
|
|
using Prism.Regions;
|
|
using Prism.Commands;
|
|
|
|
|
|
// ReSharper disable CheckNamespace
|
|
// ReSharper disable MemberCanBePrivate.Global
|
|
// ReSharper disable InconsistentNaming
|
|
|
|
namespace TTSImport
|
|
{
|
|
/// <summary>
|
|
/// this class handles Level Trigger edit/create functionality
|
|
/// </summary>
|
|
[PartCreationPolicy(CreationPolicy.Shared)]
|
|
public class AnalogChannelsViewModel : IAnalogChannelsViewModel
|
|
{
|
|
/// <summary>
|
|
/// The Hardware Scan view
|
|
/// </summary>
|
|
public IAnalogChannelsView View { get; set; }
|
|
|
|
private IEventAggregator _eventAggregator { get; }
|
|
private IRegionManager _regionManager;
|
|
private IUnityContainer UnityContainer { get; }
|
|
|
|
public InteractionRequest<Notification> NotificationRequest { get; }
|
|
public InteractionRequest<Confirmation> ConfirmationRequest { get; }
|
|
|
|
/// <inheritdoc />
|
|
/// <summary>
|
|
/// Occurs when a property value changes.
|
|
/// </summary>
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
public void OnPropertyChanged(string propertyName)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
|
|
#region constructors and initializers
|
|
/// <summary>
|
|
/// Creates a new instance of the TechnologyDomainEditViewModel.
|
|
/// </summary>
|
|
/// <param name="view"></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 AnalogChannelsViewModel(IAnalogChannelsView view, IRegionManager regionManager,
|
|
IEventAggregator eventAggregator, IUnityContainer unityContainer)
|
|
{
|
|
View = view;
|
|
View.DataContext = this;
|
|
|
|
NotificationRequest = new InteractionRequest<Notification>();
|
|
ConfirmationRequest = new InteractionRequest<Confirmation>();
|
|
|
|
_eventAggregator = eventAggregator;
|
|
UnityContainer = unityContainer;
|
|
_regionManager = regionManager;
|
|
_eventAggregator.GetEvent<RaiseNotification>().Subscribe(OnRaiseNotification);
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>()
|
|
.Subscribe(OnBusyIndicatorNotification, ThreadOption.PublisherThread, true);
|
|
_eventAggregator.GetEvent<AssignedChannelsChangedEvent>().Subscribe(OnAssignedChannelsChangedEvent,
|
|
ThreadOption.PublisherThread, true);
|
|
_eventAggregator.GetEvent<TTSImportHardwareScanFinishedEvent>()
|
|
.Subscribe(OnHardwareScanComplete, ThreadOption.PublisherThread, true);
|
|
_eventAggregator.GetEvent<EIDMappingEvent>()
|
|
.Subscribe(OnEIDComplete, ThreadOption.PublisherThread, true);
|
|
}
|
|
#endregion
|
|
|
|
#region Methods
|
|
private void OnEIDComplete(IDictionary<string, string> sensorIdToChannelId)
|
|
{
|
|
var channelIdToSensorId = new Dictionary<string, string>();
|
|
using (var e = sensorIdToChannelId.GetEnumerator())
|
|
{
|
|
while (e.MoveNext())
|
|
{
|
|
channelIdToSensorId[e.Current.Value] = e.Current.Key;
|
|
}
|
|
}
|
|
_hardwareChannelIdToSensorId = channelIdToSensorId;
|
|
}
|
|
|
|
public string Validate()
|
|
{
|
|
var bEmptyChannelCodes = false;
|
|
|
|
foreach (var channel in DASChannels)
|
|
{
|
|
if (null == channel.Channel)
|
|
{
|
|
continue;
|
|
}
|
|
if (string.IsNullOrWhiteSpace(channel.ToyotaCode))
|
|
{
|
|
bEmptyChannelCodes = true;
|
|
}
|
|
}
|
|
return bEmptyChannelCodes ? StringResources.EmptyChannelCodeWarning : string.Empty;
|
|
}
|
|
private void OnHardwareScanComplete(List<IDASHardware> hardware)
|
|
{
|
|
_hardware = hardware;
|
|
}
|
|
|
|
private void OnAssignedChannelsChangedEvent(ITTSSetup setup)
|
|
{
|
|
if (!Application.Current.Dispatcher.CheckAccess())
|
|
{
|
|
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
OnAssignedChannelsChangedEvent(setup);
|
|
}));
|
|
return;
|
|
}
|
|
_setup = setup;
|
|
if (null == _hardware || null == _setup) { return; }
|
|
var channels = new ObservableCollection<DASChannel>();
|
|
var remainingChannels = new ObservableCollection<ITTSChannelRecord>();
|
|
|
|
var channelIdToDASChannel = new Dictionary<string, DASChannel>();
|
|
foreach (var das in _hardware)
|
|
{
|
|
if (das.IsSLICEEthernetController) { continue; }
|
|
var ichannels = das.GetIHardwareChannels();
|
|
foreach (var ch in ichannels)
|
|
{
|
|
if (!ch.IsAnalog) { continue; }
|
|
var newChannel = new DASChannel(ch);
|
|
if (_hardwareChannelIdToSensorId.ContainsKey(ch.GetId()))
|
|
{
|
|
newChannel.EID = _hardwareChannelIdToSensorId[ch.GetId()];
|
|
}
|
|
channels.Add(newChannel);
|
|
channelIdToDASChannel[newChannel.HardwareChannel.GetId()] = newChannel;
|
|
}
|
|
}
|
|
|
|
foreach (var channelRecord in _setup.Channels)
|
|
{
|
|
if (channelRecord.IsEmptyRecord) { continue; }
|
|
if (channelRecord.IsDigitalInput) { continue; }
|
|
if (channelRecord.IsDigitalOutput) { continue; }
|
|
if (channelRecord.IsSquib) { continue; }
|
|
if (!channelRecord.IsChannelCodeValid) { continue; }
|
|
if (channelRecord.ChannelCode == TTSChannelRecord.NONE) { continue; }
|
|
if (null != channelRecord.HardwareChannel)
|
|
{
|
|
var key = channelRecord.HardwareChannel.GetId();
|
|
if (channelIdToDASChannel.ContainsKey(key))
|
|
{
|
|
channelIdToDASChannel[key].SetITTSChannelRecord(channelRecord);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
remainingChannels.Add(channelRecord);
|
|
}
|
|
}
|
|
|
|
DASChannels = channels;
|
|
RemainingChannels = remainingChannels;
|
|
OnPropertyChanged("DASChannels");
|
|
OnPropertyChanged("RemainingChannels");
|
|
}
|
|
public void Cleanup()
|
|
{
|
|
}
|
|
|
|
public Task CleanupAsync()
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public void Initialize()
|
|
{
|
|
}
|
|
|
|
public void Initialize(object parameter)
|
|
{
|
|
}
|
|
|
|
public void Initialize(object parameter, object model)
|
|
{
|
|
}
|
|
|
|
public Task InitializeAsync()
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task InitializeAsync(object parameter)
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public void Activated()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Private Event handler for RaiseNotification event.
|
|
/// </summary>
|
|
private void OnBusyIndicatorNotification(bool eventArg)
|
|
{
|
|
IsBusy = eventArg;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Private Event handler for RaiseNotification event.
|
|
/// </summary>
|
|
private void OnRaiseNotification(NotificationContentEventArgs eventArgsWithTitle)
|
|
{
|
|
// The NotificationRequest.Raise triggers the Invoke() method of the PopupWindowAction object to show the NotificationWindow window
|
|
// Notification object expects a NotificationContentEventArgsWithoutTitle object and a Title string.
|
|
var eventArgsWithoutTitle = new NotificationContentEventArgs(eventArgsWithTitle.Message, "",
|
|
eventArgsWithTitle.Image, string.Empty);
|
|
|
|
NotificationRequest.Raise(new Notification
|
|
{
|
|
Content = eventArgsWithoutTitle,
|
|
Title = eventArgsWithTitle.Title
|
|
});
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
private ITTSSetup _setup;
|
|
private IList<IDASHardware> _hardware;
|
|
private IDictionary<string, string> _hardwareChannelIdToSensorId = new Dictionary<string, string>();
|
|
public bool IsDirty { get; private set; }
|
|
private bool _isBusy;
|
|
|
|
public bool IsBusy
|
|
{
|
|
get => _isBusy;
|
|
set
|
|
{
|
|
_isBusy = value;
|
|
OnPropertyChanged("IsBusy");
|
|
}
|
|
}
|
|
|
|
private bool _isMenuIncluded;
|
|
|
|
public bool IsMenuIncluded
|
|
{
|
|
get => _isMenuIncluded;
|
|
set
|
|
{
|
|
_isMenuIncluded = value;
|
|
OnPropertyChanged("IsMenuIncluded");
|
|
}
|
|
}
|
|
|
|
private bool _isNavigationIncluded;
|
|
|
|
public bool IsNavigationIncluded
|
|
{
|
|
get => _isNavigationIncluded;
|
|
set
|
|
{
|
|
_isNavigationIncluded = value;
|
|
OnPropertyChanged("IsNavigationIncluded");
|
|
}
|
|
}
|
|
|
|
public bool AssignEnabled { get; set; }
|
|
public bool RemoveEnabled { get; set; }
|
|
public bool EnableOrDisableEnabled { get; set; }
|
|
public ObservableCollection<DASChannel> DASChannels { get; set; } = new ObservableCollection<DASChannel>();
|
|
public ObservableCollection<ITTSChannelRecord> RemainingChannels { get; set; } =
|
|
new ObservableCollection<ITTSChannelRecord>();
|
|
|
|
private ITTSChannelRecord _selectedRemainingChannel;
|
|
public ITTSChannelRecord SelectedRemainingChannel
|
|
{
|
|
get => _selectedRemainingChannel;
|
|
set
|
|
{
|
|
_selectedRemainingChannel = value;
|
|
if (null == _selectedRemainingChannel || null == SelectedDASChannel) return;
|
|
AssignEnabled = true;
|
|
OnPropertyChanged("AssignEnabled");
|
|
}
|
|
}
|
|
private DASChannel _selectedDASChannel;
|
|
public DASChannel SelectedDASChannel
|
|
{
|
|
get => _selectedDASChannel;
|
|
set
|
|
{
|
|
_selectedDASChannel = value;
|
|
DetermineRemoveEnableStatus();
|
|
}
|
|
}
|
|
public void DetermineRemoveEnableStatus()
|
|
{
|
|
if (_selectedDASChannel?.Channel != null)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(_selectedDASChannel.EID) &&
|
|
_selectedDASChannel.EID == _selectedDASChannel.Channel.SensorEID)
|
|
{
|
|
//can only be replaced, can't be removed
|
|
RemoveEnabled = false;
|
|
}
|
|
RemoveEnabled = true;
|
|
}
|
|
else
|
|
{
|
|
RemoveEnabled = false;
|
|
}
|
|
OnPropertyChanged("RemoveEnabled");
|
|
AssignEnabled = null != _selectedDASChannel && null != _selectedRemainingChannel;
|
|
OnPropertyChanged("AssignEnabled");
|
|
EnableOrDisableEnabled = null != _selectedDASChannel && null != _selectedDASChannel.Channel;
|
|
OnPropertyChanged("EnableOrDisableEnabled");
|
|
OnPropertyChanged("EnableOrDisableText");
|
|
}
|
|
|
|
public string EnableOrDisableText
|
|
{
|
|
get
|
|
{
|
|
if (SelectedDASChannel?.Channel == null)
|
|
{
|
|
return StringResources.Analog_Enable;
|
|
}
|
|
return SelectedDASChannel.Channel.Disabled
|
|
? StringResources.Analog_Enable
|
|
: StringResources.Analog_Disable;
|
|
}
|
|
}
|
|
#endregion Properties
|
|
|
|
#region Commands
|
|
#region assign
|
|
/// <summary>
|
|
/// Assign a channel code to a channel
|
|
/// </summary>
|
|
private DelegateCommand _assignCommand;
|
|
public DelegateCommand AssignCommand => _assignCommand ?? (_assignCommand = new DelegateCommand(Assign));
|
|
private void Assign()
|
|
{
|
|
if (SelectedRemainingChannel == null) { return; }
|
|
|
|
var error = string.Empty;
|
|
if (!VoltageIsValid(SelectedRemainingChannel, SelectedDASChannel, out error))
|
|
{
|
|
var window = Application.Current.MainWindow;
|
|
if (null == window) { return; }
|
|
MessageBox.Show(window, error, StringResources.AssignSensorExcitationError, MessageBoxButton.OK);
|
|
return;
|
|
}
|
|
_eventAggregator.GetEvent<TTSImportTestSetupChangedEvent>().Publish(_setup);
|
|
//BEFORE we go any further, check the state of sensor ids
|
|
//if the channel has a sensor id AND there's a sensor on the channel with the same id
|
|
//then prompt on replacing the id
|
|
//IF the channel has a sensor id and there's no sensor on the channel BUT the new sensor has a different id
|
|
//then prompt on replacing the id
|
|
var bReplacingID = false;
|
|
if (!string.IsNullOrWhiteSpace(SelectedDASChannel.EID))
|
|
{
|
|
if (null != SelectedRemainingChannel && SelectedRemainingChannel.SensorEID != SelectedDASChannel.EID)
|
|
{
|
|
bReplacingID = true;
|
|
}
|
|
//if existing channel has this ID, we will need to clear out the old id and assign a new one...
|
|
if (null != SelectedDASChannel.Channel &&
|
|
SelectedDASChannel.Channel.SensorEID == SelectedDASChannel.EID)
|
|
{
|
|
bReplacingID = true;
|
|
}
|
|
}
|
|
else if (_setup.RequireEIDFound && !string.IsNullOrWhiteSpace(SelectedRemainingChannel.SensorEID))
|
|
{
|
|
var window = Application.Current.MainWindow;
|
|
if (null == window) { return; }
|
|
var msg = string.Format(StringResources.AllowEIDToBlankChannelChallenge, SelectedRemainingChannel.SensorSerialNumber);
|
|
msg = msg.Replace("\\r\\n", "\r\n");
|
|
|
|
var dialogResult = MessageBox.Show(window, msg, StringResources.UserFeedbackRequired, MessageBoxButton.OKCancel);
|
|
APILogger.Log(msg, $"User pressed {dialogResult.ToString()}");
|
|
if (dialogResult == MessageBoxResult.OK)
|
|
{
|
|
SelectedRemainingChannel.SensorEID = string.Empty;
|
|
AssignWork();
|
|
}
|
|
return;
|
|
}
|
|
if (bReplacingID)
|
|
{
|
|
var window = Application.Current.MainWindow;
|
|
if (null == window) { return; }
|
|
var dialogResult = MessageBox.Show(window, StringResources.AssignSensorPrompt, StringResources.UserFeedbackRequired, MessageBoxButton.YesNo);
|
|
APILogger.Log(StringResources.AssignSensorPrompt, $"User pressed {dialogResult.ToString()}");
|
|
if (dialogResult == MessageBoxResult.Yes)
|
|
{
|
|
AssignWork();
|
|
}
|
|
return;
|
|
}
|
|
|
|
AssignWork();
|
|
}
|
|
|
|
/// <summary>
|
|
/// returns True if the sensor's voltage is supported by the hardware channel, or an error message and False if not
|
|
/// </summary>
|
|
/// <param name="selectedRemainingChannel"></param>
|
|
/// <param name="selectedDASChannel"></param>
|
|
/// <param name="error"></param>
|
|
/// <returns></returns>
|
|
private bool VoltageIsValid(ITTSChannelRecord selectedRemainingChannel, DASChannel selectedDASChannel, out string error)
|
|
{
|
|
error = string.Empty;
|
|
var voltageEnum = ExcitationVoltageOptions.ExcitationVoltageOption.Undefined;
|
|
try
|
|
{
|
|
voltageEnum = Test.Module.Channel.Sensor.GetExcitationVoltageEnumFromMagnitude(selectedRemainingChannel.SensorExcitationVolts);
|
|
}
|
|
catch { } //GetExcitationVoltageEnumFromMagnitude will throw an exception if an invalid voltage is passed to it
|
|
|
|
if (selectedDASChannel.HardwareChannel.IsSupportedExcitation(voltageEnum)) return true;
|
|
error = string.Format(StringResources.InvalidExcitationAssignment, selectedRemainingChannel.SensorExcitationVolts);
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// removes the channel as a selected channel for any level triggers
|
|
/// removes the channel as a possible channel for any level triggers
|
|
/// </summary>
|
|
/// <param name="channel"></param>
|
|
private void RemoveFromLevelTriggers(ITTSChannelRecord channel)
|
|
{
|
|
if (null != _setup)
|
|
{
|
|
foreach (var lt in _setup.LevelTriggers)
|
|
{
|
|
lt.Remove(channel);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// adds the channel as a possible channel to any level triggers
|
|
/// </summary>
|
|
/// <param name="channel"></param>
|
|
private void AddToLevelTriggers(ITTSChannelRecord channel)
|
|
{
|
|
if (null != _setup)
|
|
{
|
|
foreach (var lt in _setup.LevelTriggers)
|
|
{
|
|
lt.Add(channel);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// assigns a channel record to a physical channel
|
|
/// </summary>
|
|
private void AssignWork()
|
|
{
|
|
if (null == SelectedDASChannel || null == SelectedRemainingChannel) { return; }
|
|
var excitation =
|
|
Test.Module.Channel.Sensor.GetExcitationVoltageEnumFromMagnitude(SelectedRemainingChannel
|
|
.SensorExcitationVolts);
|
|
if (!SelectedDASChannel.HardwareChannel.IsSupportedExcitation(excitation))
|
|
{
|
|
var window = Application.Current.MainWindow;
|
|
if (null == window) { return; }
|
|
var msg = string.Format(StringResources.ExcitationNotSupportedByChannel, excitation.ToString());
|
|
var result = MessageBox.Show(window, msg, StringResources.Warning, MessageBoxButton.OK);
|
|
APILogger.Log(msg, $"user pressed {result.ToString()}");
|
|
return;
|
|
}
|
|
|
|
if (null != SelectedDASChannel.Channel)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(SelectedDASChannel.EID))
|
|
{
|
|
SelectedDASChannel.Channel.SensorEID = "";
|
|
}
|
|
RemainingChannels.Add(SelectedDASChannel.Channel);
|
|
RemoveFromLevelTriggers(SelectedDASChannel.Channel);
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(SelectedDASChannel.EID))
|
|
{
|
|
SelectedRemainingChannel.SensorEID = SelectedDASChannel.EID;
|
|
}
|
|
|
|
SelectedDASChannel.SetITTSChannelRecord(SelectedRemainingChannel);
|
|
|
|
AddToLevelTriggers(SelectedDASChannel.Channel);
|
|
var channel = SelectedRemainingChannel;
|
|
var index = RemainingChannels.IndexOf(channel);
|
|
SelectedRemainingChannel = null;
|
|
RemainingChannels.Remove(channel);
|
|
CollectionViewSource.GetDefaultView(DASChannels)?.Refresh();
|
|
if (index < RemainingChannels.Count)
|
|
{
|
|
SelectedRemainingChannel = RemainingChannels[index];
|
|
OnPropertyChanged("SelectedRemainingChannel");
|
|
}
|
|
else if (RemainingChannels.Count > 0)
|
|
{
|
|
SelectedRemainingChannel = RemainingChannels[index - 1];
|
|
OnPropertyChanged("SelectedRemainingChannel");
|
|
}
|
|
index = DASChannels.IndexOf(SelectedDASChannel);
|
|
for (var i = index; i < DASChannels.Count; i++)
|
|
{
|
|
var dasChannel = DASChannels[i];
|
|
if (null != dasChannel.Channel) { continue; }
|
|
SelectedDASChannel = dasChannel;
|
|
OnPropertyChanged("SelectedDASChannel");
|
|
return;
|
|
}
|
|
//didn't find a match, start from the beginning?
|
|
for (var i = 0; i < index; i++)
|
|
{
|
|
var dasChannel = DASChannels[i];
|
|
if (null != dasChannel.Channel)
|
|
{
|
|
continue;
|
|
}
|
|
SelectedDASChannel = dasChannel;
|
|
OnPropertyChanged("SelectedDASChannel");
|
|
return;
|
|
}
|
|
//if we get here there's no new channel to go to, change remove/enable/disable button status
|
|
OnPropertyChanged("SelectedDASChannel");
|
|
DetermineRemoveEnableStatus();
|
|
}
|
|
#endregion
|
|
#region remove
|
|
private DelegateCommand _removeCommand;
|
|
public DelegateCommand RemoveCommand => _removeCommand ?? (_removeCommand = new DelegateCommand(Remove));
|
|
/// <summary>
|
|
/// remove a hardware channel assignment (does not remove the channel from the test setup though?)
|
|
/// </summary>
|
|
private void Remove()
|
|
{
|
|
if (null == SelectedDASChannel || null == SelectedDASChannel.Channel) { return; }
|
|
_eventAggregator.GetEvent<TTSImportTestSetupChangedEvent>().Publish(_setup);
|
|
RemainingChannels.Add(SelectedDASChannel.Channel);
|
|
SelectedDASChannel.SetITTSChannelRecord(null);
|
|
CollectionViewSource.GetDefaultView(DASChannels)?.Refresh();
|
|
var index = DASChannels.IndexOf(SelectedDASChannel);
|
|
for (var i = index; i < DASChannels.Count; i++)
|
|
{
|
|
if (null == DASChannels[i].Channel) { continue; }
|
|
SelectedDASChannel = DASChannels[i];
|
|
OnPropertyChanged("SelectedDASChannel");
|
|
return;
|
|
}
|
|
for (var i = 0; i < index; i++)
|
|
{
|
|
if (null == DASChannels[i].Channel) { continue; }
|
|
SelectedDASChannel = DASChannels[i];
|
|
OnPropertyChanged("SelectedDASChannel");
|
|
return;
|
|
}
|
|
//if we get here there's no new channel to go to, but we need to set the remove/enable/disable button status
|
|
OnPropertyChanged("SelectedDASChannel");
|
|
DetermineRemoveEnableStatus();
|
|
}
|
|
#endregion
|
|
#region enableordisable
|
|
private DelegateCommand _enableOrDisableCommand;
|
|
public DelegateCommand EnableOrDisableCommand =>
|
|
_enableOrDisableCommand ?? (_enableOrDisableCommand = new DelegateCommand(EnableOrDisable));
|
|
/// <summary>
|
|
/// enables or disables a channel in the test.
|
|
/// </summary>
|
|
private void EnableOrDisable()
|
|
{
|
|
if (SelectedDASChannel?.Channel == null) { return; }
|
|
SelectedDASChannel.Channel.Disabled = !SelectedDASChannel.Channel.Disabled;
|
|
SelectedDASChannel.Disabled = SelectedDASChannel.Channel.Disabled;
|
|
if (SelectedDASChannel.Channel.Disabled)
|
|
{
|
|
RemoveFromLevelTriggers(SelectedDASChannel.Channel);
|
|
}
|
|
else
|
|
{
|
|
AddToLevelTriggers(SelectedDASChannel.Channel);
|
|
}
|
|
OnPropertyChanged("EnableOrDisableText");
|
|
_eventAggregator.GetEvent<TTSImportTestSetupChangedEvent>().Publish(_setup);
|
|
}
|
|
#endregion
|
|
#endregion
|
|
}
|
|
}
|