/// <summary>
/// Initialize a new instance of the class and set the function delegates, properties and member variables to those values associated with the
/// specified communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationWatch(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
}
/// <summary>
/// Initialize a new instance of the class
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationSelfTest(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
m_SelfTestMarshal = new SelfTestMarshal(communicationInterface.CommDevice);
}
/// <summary>
/// Initialize a new instance of the class and set the properties and member variables to those values associated with the specified
/// communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationSelfTestOffline(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
}
/// <summary>
/// Initializes an new instance of the form. Defines the communication interface and then downloads the current default data stream parameters and displays these
/// on the form.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface that is to be used to communicate with the VCU.</param>
/// <param name="worksetCollection">The workset collection that is to be managed.</param>
/// <param name="log">The selected event log.</param>
public FormConfigureFaultLogParameters(ICommunicationParent communicationInterface, WorksetCollection worksetCollection, Log log)
: base(worksetCollection)
{
InitializeComponent();
// Move the position of the Cancel buttons.
m_ButtonCancel.Location = m_ButtonApply.Location;
// Initialize the communication interface.
if (communicationInterface is CommunicationParent)
{
CommunicationInterface = new CommunicationEvent(communicationInterface);
}
else
{
CommunicationInterface = new CommunicationEventOffline(communicationInterface);
}
Debug.Assert(CommunicationInterface != null);
// Don't allow the user to edit the workset until the security level of the workset has been established.
ModifyEnabled = false;
m_NumericUpDownSampleMultiple.Enabled = ModifyEnabled;
// ----------------------------------------------------
// Get the current data stream parameters from the VCU.
// ----------------------------------------------------
short variableCount, pointCount, sampleMultiple;
short[] watchIdentifiers, dataTypes;
try
{
CommunicationInterface.GetDefaultStreamInformation(out variableCount, out pointCount, out sampleMultiple, out watchIdentifiers, out dataTypes);
}
catch (Exception)
{
MessageBox.Show(Resources.MBTGetDefaultStreamParametersFailed, Resources.MBCaptionError, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Convert the parameters to a workset.
Workset_t workset = CommunicationInterface.ConvertToWorkset("GetDefaultStreamInformation()", watchIdentifiers, sampleMultiple);
// Search the list of worksets for a match.
m_WorksetFromVCU = workset;
m_WorksetToCompare = workset;
Workset_t matchedWorkset = Workset.FaultLog.Worksets.Find(CompareWorkset);
// Check whether a match was found.
if (matchedWorkset.WatchItems == null)
{
// No - Create a new workset.
workset.Name = DefaultNewWorksetName;
// Set the flag to indicate that the workset does not exist and that any changes will be saved as a new workset.
m_CreateMode = true;
m_ComboBoxWorkset.DropDownStyle = ComboBoxStyle.DropDown;
// Ensure that the TextChanged event is not triggered as a result of specifying the Text property of the TextBox control.
m_TextBoxName.TextChanged -= new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Text = workset.Name;
m_TextBoxName.TextChanged += new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Enabled = true;
}
else
{
// Yes - Update the name and security level of the workset.
workset = matchedWorkset;
// Set the flag to indicate that the form already exists and any changes will result in the existing workset being modified.
m_CreateMode = false;
m_ComboBoxWorkset.DropDownStyle = ComboBoxStyle.DropDownList;
// Ensure that the TextChanged event is not triggered as a result of specifying the Text property of the TextBox control.
m_TextBoxName.TextChanged -= new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Text = workset.Name;
m_TextBoxName.TextChanged += new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Enabled = false;
}
// Keep a record of the selected workset. This must be set up before the call to SetEnabledEditNewCopyRename().
m_SelectedWorkset = workset;
SetEnabledEditNewCopyRename(true);
// Display the name of the default workset on the ComboBox control.
// Ensure that the SelectionChanged event is not triggered as a result of specifying the Text property of the ComboBox control.
m_ComboBoxWorkset.SelectedIndexChanged -= new EventHandler(m_ComboBoxWorkset_SelectedIndexChanged);
m_ComboBoxWorkset.Text = workset.Name;
m_ComboBoxWorkset.SelectedIndexChanged += new EventHandler(m_ComboBoxWorkset_SelectedIndexChanged);
LoadWorkset(workset);
// Update the EntryCountMax property to reflect the actual number of watch variables associated with the current event log.
m_EntryCountMax = log.DataStreamTypeParameters.WatchVariablesMax;
UpdateCount();
// Check whether the 'Row Header' ListBox can be used to display the channel numbers. This is only possible if
// the project doesn't support multiple data stream types and the number of parameters supported by the data
// stream can be displayed on the TabPage without the need for scroll bars i.e. <= WatchSizeFaultLogMax.
if ((Parameter.SupportsMultipleDataStreamTypes == false) && (Parameter.WatchSizeFaultLog <= WatchSizeFaultLogMax))
{
AddRowHeader();
}
else
{
NoRowHeader();
}
// Disable all options other than save if the downloaded workset doesn't exist.
if (m_CreateMode == true)
{
SetEnabledEditNewCopyRename(false);
}
// Allow the user to save the workset if it doesn't already exist.
m_TSBSave.Enabled = (m_CreateMode == true) ? true : false;
}
/// <summary>
/// Initialize a new instance of the class and set the function delegates, properties and member variables.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to
/// be used to initialize the class.</param>
public CommunicationParent(ICommunicationParent communicationInterface)
: this()
{
m_CommunicationSetting = communicationInterface.CommunicationSetting;
m_CommDevice = communicationInterface.CommDevice;
m_WatchClockMarshal = communicationInterface.WatchClockMarshall;
}
/// <summary>
/// Initialize a new instance of the class and set the properties and member variables to those values associated with the specified
/// communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationSelfTestOffline(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
}
/// <summary>
/// Initialize a new instance of the class and set the function delegates, properties and member variables to those values associated with the
/// specified communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to
/// be used to initialize the class.</param>
public CommunicationEvent(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
#region - [Initialize VcuCommunication.event.cpp Function Delegates] -
// ----------------------------------------------------------------------
// Initialize the function delegates to either the VcuCommunication32.dll
// or VcuCommunication64.dll functions depending upon whether the
// Windows operating system is 64 bit or 32 bit.
// ----------------------------------------------------------------------
if (m_Is64BitOperatingSystem == true)
{
m_LoadFaultlog = VcuCommunication64Event.LoadFaultlog;
m_CheckFaultlogger = VcuCommunication64Event.CheckFaultlogger;
m_GetFaultHdr = VcuCommunication64Event.GetFaultHdr;
m_GetFaultVar = VcuCommunication64Event.GetFaultVar;
m_GetFltFlagInfo = VcuCommunication64Event.GetFltFlagInfo;
m_GetFltHistInfo = VcuCommunication64Event.GetFltHistInfo;
m_FreeEventLogMemory = VcuCommunication64Event.FreeEventLogMemory;
m_SetFaultFlags = VcuCommunication64Event.SetFaultFlags;
m_ClearEvent = VcuCommunication64Event.ClearEvent;
m_InitializeEventLog = VcuCommunication64Event.InitializeEventLog;
m_GetStream = VcuCommunication64Event.GetStream;
m_GetStreamInformation = VcuCommunication64Event.GetStreamInformation;
m_GetDefaultStreamInformation = VcuCommunication64Event.GetDefaultStreamInformation;
m_SetDefaultStreamInformation = VcuCommunication64Event.SetDefaultStreamInformation;
m_GetEventLog = VcuCommunication64Event.GetEventLog;
m_ChangeEventLog = VcuCommunication64Event.ChangeEventLog;
m_ExitEventLog = VcuCommunication64Event.ExitEventLog;
}
else
{
m_LoadFaultlog = VcuCommunication32Event.LoadFaultlog;
m_CheckFaultlogger = VcuCommunication32Event.CheckFaultlogger;
m_GetFaultHdr = VcuCommunication32Event.GetFaultHdr;
m_GetFaultVar = VcuCommunication32Event.GetFaultVar;
m_GetFltFlagInfo = VcuCommunication32Event.GetFltFlagInfo;
m_GetFltHistInfo = VcuCommunication32Event.GetFltHistInfo;
m_FreeEventLogMemory = VcuCommunication32Event.FreeEventLogMemory;
m_SetFaultFlags = VcuCommunication32Event.SetFaultFlags;
m_ClearEvent = VcuCommunication32Event.ClearEvent;
m_InitializeEventLog = VcuCommunication32Event.InitializeEventLog;
m_GetStream = VcuCommunication32Event.GetStream;
m_GetStreamInformation = VcuCommunication32Event.GetStreamInformation;
m_GetDefaultStreamInformation = VcuCommunication32Event.GetDefaultStreamInformation;
m_SetDefaultStreamInformation = VcuCommunication32Event.SetDefaultStreamInformation;
m_GetEventLog = VcuCommunication32Event.GetEventLog;
m_ChangeEventLog = VcuCommunication32Event.ChangeEventLog;
m_ExitEventLog = VcuCommunication32Event.ExitEventLog;
}
#endregion - [Initialize VcuCommunication.event.cpp Function Delegates] -
}
/// <summary>
/// Initialize a new instance of the class and set the properties and member variables to those values associated with the specified
/// communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationParentOffline(ICommunicationParent communicationInterface)
{
// Initialize the watch element array.
m_WatchElements = new WatchElement_t[Parameter.WatchSize];
m_CommunicationSetting = communicationInterface.CommunicationSetting;
}
/// <summary>
/// Initializes an new instance of the form. Defines the communication interface and then downloads the current default data stream parameters and displays these
/// on the form.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface that is to be used to communicate with the VCU.</param>
/// <param name="worksetCollection">The workset collection that is to be managed.</param>
/// <param name="log">The selected event log.</param>
public FormConfigureFaultLogParameters(ICommunicationParent communicationInterface, WorksetCollection worksetCollection, Log log)
: base(worksetCollection)
{
InitializeComponent();
// Only one column is required for this workset so delete the tab pages associated with columns 2 and 3.
m_TabControlColumn.TabPages.Remove(m_TabPageColumn2);
m_TabControlColumn.TabPages.Remove(m_TabPageColumn3);
// Move the position of the Cancel buttons.
m_ButtonCancel.Location = m_ButtonApply.Location;
// Check the mode of the PTU.
if (communicationInterface == null)
{
CommunicationInterface = null;
}
else if (communicationInterface is CommunicationParent)
{
// The PTU is in online mode.
CommunicationInterface = new CommunicationEvent(communicationInterface);
}
else
{
// The PTU is in simulation mode (originally referred to as offline mode).
CommunicationInterface = new CommunicationEventOffline(communicationInterface);
}
// Don't allow the user to edit the workset until the security level of the workset has been established.
ModifyEnabled = false;
m_NumericUpDownSampleMultiple.Enabled = ModifyEnabled;
#region - [ToolTipText] -
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonUpload].ToolTipText = Resources.FunctionKeyToolTipDataStreamUpload;
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonSave].ToolTipText = Resources.FunctionKeyToolTipDataStreamSave;
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonEdit].ToolTipText = Resources.FunctionKeyToolTipDataStreamConfigure;
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonNew].ToolTipText = Resources.FunctionKeyToolTipDataStreamCreate;
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonCopy].ToolTipText = Resources.FunctionKeyToolTipDataStreamCopy;
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonRename].ToolTipText = Resources.FunctionKeyToolTipDataStreamRename;
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonDelete].ToolTipText = Resources.FunctionKeyToolTipDataStreamDelete;
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonSetAsDefault].ToolTipText = Resources.FunctionKeyToolTipDataStreamSetAsDefault;
m_ToolStrip.Items[CommonConstants.KeyToolStripButtonOverrideSecurity].ToolTipText = Resources.FunctionKeyToolTipDataStreamOverrideSecurity;
#endregion - [ToolTipText] -
#region - [Get the Current Data Stream from the VCU] -
// This only applies if the PTU is online.
Workset_t workset;
if (CommunicationInterface != null)
{
short variableCount, pointCount, sampleMultiple;
short[] watchIdentifiers, dataTypes;
try
{
CommunicationInterface.GetDefaultStreamInformation(out variableCount, out pointCount, out sampleMultiple, out watchIdentifiers, out dataTypes);
}
catch (Exception)
{
MessageBox.Show(Resources.MBTGetDefaultStreamParametersFailed, Resources.MBCaptionError, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Convert the parameters to a workset.
workset = CommunicationInterface.ConvertToWorkset("GetDefaultStreamInformation()", watchIdentifiers, sampleMultiple);
// Search the list of worksets for a match.
m_WorksetFromVCU = workset;
m_WorksetToCompare = workset;
Workset_t matchedWorkset = Workset.FaultLog.Worksets.Find(CompareWorkset);
// Check whether a match was found.
if (matchedWorkset.WatchItems == null)
{
// No - Create a new workset.
workset.Name = DefaultNewWorksetName;
// Set the flag to indicate that the workset does not exist and that any changes will be saved as a new workset.
m_CreateMode = true;
m_ComboBoxWorkset.DropDownStyle = ComboBoxStyle.DropDown;
// Ensure that the TextChanged event is not triggered as a result of specifying the Text property of the TextBox control.
m_TextBoxName.TextChanged -= new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Text = workset.Name;
m_TextBoxName.TextChanged += new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Enabled = true;
}
else
{
// Yes - Update the name and security level of the workset.
workset = matchedWorkset;
// Set the flag to indicate that the form already exists and any changes will result in the existing workset being modified.
m_CreateMode = false;
m_ComboBoxWorkset.DropDownStyle = ComboBoxStyle.DropDownList;
// Ensure that the TextChanged event is not triggered as a result of specifying the Text property of the TextBox control.
m_TextBoxName.TextChanged -= new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Text = workset.Name;
m_TextBoxName.TextChanged += new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Enabled = false;
}
}
else
{
// Load the default workset.
workset = worksetCollection.Worksets[worksetCollection.DefaultIndex];
// Set the flag to indicate that the form already exists and any changes will result in the existing workset being modified.
m_CreateMode = false;
m_ComboBoxWorkset.DropDownStyle = ComboBoxStyle.DropDownList;
// Ensure that the TextChanged event is not triggered as a result of specifying the Text property of the TextBox control.
m_TextBoxName.TextChanged -= new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Text = workset.Name;
m_TextBoxName.TextChanged += new EventHandler(m_TextBoxName_TextChanged);
m_TextBoxName.Enabled = false;
}
#endregion - [Get the Current Data Stream from the VCU] -
// Keep a record of the selected workset. This must be set up before the call to SetEnabledToolStripButtons().
m_SelectedWorkset = workset;
SetEnabledToolStripButtons(true);
// Update the 'Default' Image that identifies whether the selected workset is the default workset or not.
m_PictureBoxDefault.Visible = (m_SelectedWorkset.Name.Equals(m_WorksetCollection.DefaultName)) ? true : false;
// Display the name of the workset on the ComboBox control.
// Ensure that the SelectionChanged event is not triggered as a result of specifying the Text property of the ComboBox control.
m_ComboBoxWorkset.SelectedIndexChanged -= new EventHandler(m_ComboBoxWorkset_SelectedIndexChanged);
m_ComboBoxWorkset.Text = workset.Name;
m_ComboBoxWorkset.SelectedIndexChanged += new EventHandler(m_ComboBoxWorkset_SelectedIndexChanged);
LoadWorkset(m_SelectedWorkset);
// If an event log was specified, update the EntryCountMax property to reflect the actual number of watch variables associated with the current event log.
if (log != null)
{
m_EntryCountMax = log.DataStreamTypeParameters.WatchVariablesMax;
}
UpdateCount();
// Check whether the 'Row Header' ListBox can be used to display the channel numbers. This is only possible if
// the project doesn't support multiple data stream types and the number of parameters supported by the data
// stream can be displayed on the TabPage without the need for scroll bars i.e. <= WatchSizeFaultLogMax.
if ((Parameter.SupportsMultipleDataStreamTypes == false) && (Parameter.WatchSizeFaultLog <= WatchSizeFaultLogMax))
{
AddRowHeader();
}
else
{
NoRowHeader();
}
// Disable all options other than save if the downloaded workset doesn't exist.
if (m_CreateMode == true)
{
SetEnabledToolStripButtons(false);
}
// Allow the user to save the workset if it doesn't already exist.
m_TSBSave.Enabled = (m_CreateMode == true) ? true : false;
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
/// <param name="communicationInterface">The communication interface that is to be used to communicate with the VCU.</param>
/// <param name="log">The current event log.</param>
public FormShowEventHistory(ICommunicationParent communicationInterface, Log log)
{
InitializeComponent();
// Initialize the communication interface.
if (communicationInterface is CommunicationParent)
{
CommunicationInterface = new CommunicationEvent(communicationInterface);
}
else
{
CommunicationInterface = new CommunicationEventOffline(communicationInterface);
}
Debug.Assert(CommunicationInterface != null);
#region - [Size] -
m_DataGridViewTextColumnEnableEvent.Visible = false;
m_DataGridViewTextColumnStreamTriggered.Visible = false;
m_DataGridViewTextColumnCumulativeHistory.Visible = true;
m_DataGridViewTextColumnRecentHistory.Visible = true;
// Get the combined width of all visible DataGridView columns.
int dataGridViewWidth = 0;
DataGridViewColumn dataGridViewColumn;
for (int columnIndex = 0; columnIndex < m_DataGridViewEventStatus.Columns.Count; columnIndex++)
{
dataGridViewColumn = m_DataGridViewEventStatus.Columns[columnIndex];
if (dataGridViewColumn.Visible == true)
{
dataGridViewWidth += dataGridViewColumn.Width;
}
}
m_PanelDataGridViewEventStatus.Width = dataGridViewWidth + MarginRightDataGridViewControl;
Width = m_PanelDataGridViewEventStatus.Width + MarginRightPanelControl;
#endregion - [Size] -
#region - [Buttons] -
// Only the OK button is required for this form, move the position of the OK button so that it hides the cancel button.
m_ButtonCancel.Visible = false;
m_ButtonOK.Location = m_ButtonCancel.Location;
#endregion - [Buttons] -
#region - [Context Menu] -
// Disable those context menu options that are not applicable to this form.
m_ContextMenuStripFlags.Items[ContextMenuItemIndexEnabled].Visible = false;
m_ContextMenuStripFlags.Items[ContextMenuItemIndexStreamTriggered].Visible = false;
#endregion - [Context Menu] -
// ------------------------------------------------------------------
// Get the list of events associated with the current event log.
// ------------------------------------------------------------------
List<EventRecord> foundEventRecordList = Lookup.EventTable.RecordList.FindAll(delegate(EventRecord eventRecord)
{
// Include a try/catch block in case an event record has not been defined.
try
{
// The LOGID field of the EVENTS table actually uses the log index value which is equal to the log identifier - 1.
return (eventRecord.LogIdentifier == log.Identifier - 1);
}
catch (Exception)
{
return false;
}
});
foundEventRecordList.Sort(CompareByTaskIDByEventIDAscending);
try
{
FormGetFltHistInfo formGetFltHistInfo = new FormGetFltHistInfo(CommunicationInterface, foundEventRecordList, log);
formGetFltHistInfo.CalledFrom = this;
formGetFltHistInfo.ShowDialog();
}
catch (Exception)
{
throw new CommunicationException(Resources.EMGetFltHistInfoFailed);
}
AddList(EventStatusList);
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
/// <param name="communicationInterface">The communication interface that is to be used to communicate with the VCU.</param>
/// <param name="log">The current event log.</param>
public FormShowEventHistory(ICommunicationParent communicationInterface, Log log)
{
InitializeComponent();
// Initialize the communication interface.
if (communicationInterface is CommunicationParent)
{
CommunicationInterface = new CommunicationEvent(communicationInterface);
}
else
{
CommunicationInterface = new CommunicationEventOffline(communicationInterface);
}
Debug.Assert(CommunicationInterface != null);
#region - [Size] -
m_DataGridViewTextColumnEnableEvent.Visible = false;
m_DataGridViewTextColumnStreamTriggered.Visible = false;
m_DataGridViewTextColumnCumulativeHistory.Visible = true;
m_DataGridViewTextColumnRecentHistory.Visible = true;
// Get the combined width of all visible DataGridView columns.
int dataGridViewWidth = 0;
DataGridViewColumn dataGridViewColumn;
for (int columnIndex = 0; columnIndex < m_DataGridViewEventStatus.Columns.Count; columnIndex++)
{
dataGridViewColumn = m_DataGridViewEventStatus.Columns[columnIndex];
if (dataGridViewColumn.Visible == true)
{
dataGridViewWidth += dataGridViewColumn.Width;
}
}
m_PanelDataGridViewEventStatus.Width = dataGridViewWidth + MarginRightDataGridViewControl;
Width = m_PanelDataGridViewEventStatus.Width + MarginRightPanelControl;
#endregion - [Size] -
#region - [Buttons] -
// Only the OK button is required for this form, move the position of the OK button so that it hides the cancel button.
m_ButtonCancel.Visible = false;
m_ButtonOK.Location = m_ButtonCancel.Location;
#endregion - [Buttons] -
#region - [Context Menu] -
// Disable those context menu options that are not applicable to this form.
m_ContextMenuStripFlags.Items[ContextMenuItemIndexEnabled].Visible = false;
m_ContextMenuStripFlags.Items[ContextMenuItemIndexStreamTriggered].Visible = false;
#endregion - [Context Menu] -
// ------------------------------------------------------------------
// Get the list of events associated with the current event log.
// ------------------------------------------------------------------
List <EventRecord> foundEventRecordList = Lookup.EventTable.RecordList.FindAll(delegate(EventRecord eventRecord)
{
// Include a try/catch block in case an event record has not been defined.
try
{
// The LOGID field of the EVENTS table actually uses the log index value which is equal to the log identifier - 1.
return(eventRecord.LogIdentifier == log.Identifier - 1);
}
catch (Exception)
{
return(false);
}
});
foundEventRecordList.Sort(CompareByTaskIDByEventIDAscending);
try
{
FormGetFltHistInfo formGetFltHistInfo = new FormGetFltHistInfo(CommunicationInterface, foundEventRecordList, log);
formGetFltHistInfo.CalledFrom = this;
formGetFltHistInfo.ShowDialog();
}
catch (Exception)
{
throw new CommunicationException(Resources.EMGetFltHistInfoFailed);
}
AddList(EventStatusList);
}
/// <summary>
/// Initialize a new instance of the class and set the function delegates, properties and member variables to those values associated with the
/// specified communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationSelfTest(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
#region - [Initialize VcuCommunication.selftest.cpp Function Delegates] -
// ----------------------------------------------------------------------
// Initialize the function delegates to either the VcuCommunication32.dll
// or VcuCommunication64.dll functions depending upon whether the
// Windows operating system is 64 bit or 32 bit.
// ----------------------------------------------------------------------
if (m_Is64BitOperatingSystem == true)
{
m_GetSelfTestSpecialMessage = VcuCommunication64SelfTest.GetSelfTestSpecialMessage;
m_StartSelfTestTask = VcuCommunication64SelfTest.StartSelfTestTask;
m_ExitSelfTestTask = VcuCommunication64SelfTest.ExitSelfTestTask;
m_AbortSTSequence = VcuCommunication64SelfTest.AbortSTSequence;
m_SendOperatorAcknowledge = VcuCommunication64SelfTest.SendOperatorAcknowledge;
m_UpdateSTTestList = VcuCommunication64SelfTest.UpdateSTTestList;
m_RunPredefinedSTTests = VcuCommunication64SelfTest.RunPredefinedSTTests;
m_UpdateSTLoopCount = VcuCommunication64SelfTest.UpdateSTLoopCount;
m_ExecuteSTTestList = VcuCommunication64SelfTest.ExecuteSTTestList;
unsafe
{
m_GetSelfTestResult = VcuCommunication64SelfTest.GetSelfTestResult;
}
m_UpdateSTMode = VcuCommunication64SelfTest.UpdateSTMode;
}
else
{
m_GetSelfTestSpecialMessage = VcuCommunication32SelfTest.GetSelfTestSpecialMessage;
m_StartSelfTestTask = VcuCommunication32SelfTest.StartSelfTestTask;
m_ExitSelfTestTask = VcuCommunication32SelfTest.ExitSelfTestTask;
m_AbortSTSequence = VcuCommunication32SelfTest.AbortSTSequence;
m_SendOperatorAcknowledge = VcuCommunication32SelfTest.SendOperatorAcknowledge;
m_UpdateSTTestList = VcuCommunication32SelfTest.UpdateSTTestList;
m_RunPredefinedSTTests = VcuCommunication32SelfTest.RunPredefinedSTTests;
m_UpdateSTLoopCount = VcuCommunication32SelfTest.UpdateSTLoopCount;
m_ExecuteSTTestList = VcuCommunication32SelfTest.ExecuteSTTestList;
unsafe
{
m_GetSelfTestResult = VcuCommunication32SelfTest.GetSelfTestResult;
}
m_UpdateSTMode = VcuCommunication32SelfTest.UpdateSTMode;
}
#endregion - [Initialize VcuCommunication.selftest.cpp Function Delegates] -
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
/// <param name="communicationInterface">The communication interface that is to be used to communicate with the VCU.</param>
/// <param name="log">The current event log.</param>
public FormConfigureEventFlags(ICommunicationParent communicationInterface, Log log)
{
InitializeComponent();
// Initialize the communication interface.
if (communicationInterface is CommunicationParent)
{
CommunicationInterface = new CommunicationEvent(communicationInterface);
}
else
{
CommunicationInterface = new CommunicationEventOffline(communicationInterface);
}
Debug.Assert(CommunicationInterface != null);
#region - [Size] -
// Get the combined width of all visible DataGridView columns.
int dataGridViewWidth = 0;
DataGridViewColumn dataGridViewColumn;
for (int columnIndex = 0; columnIndex < m_DataGridViewEventStatus.Columns.Count; columnIndex++)
{
dataGridViewColumn = m_DataGridViewEventStatus.Columns[columnIndex];
if (dataGridViewColumn.Visible == true)
{
dataGridViewWidth += dataGridViewColumn.Width;
}
}
m_PanelDataGridViewEventStatus.Width = dataGridViewWidth + MarginRightDataGridViewControl;
Width = m_PanelDataGridViewEventStatus.Width + MarginRightPanelControl;
#endregion - [Size] -
// ------------------------------------------------------------------
// Get the list of events associated with the current event log.
// ------------------------------------------------------------------
List <EventRecord> foundEventRecordList;
foundEventRecordList = Lookup.EventTable.RecordList.FindAll(delegate(EventRecord eventRecord)
{
// Include a try/catch block in case an event record has not been defined.
try
{
// The LOGID field of the EVENTS table actually uses the log index value which is equal to the log identifier - 1.
return(eventRecord.LogIdentifier == log.Identifier - 1);
}
catch (Exception)
{
return(false);
}
});
foundEventRecordList.Sort(CompareByTaskIDByEventIDAscending);
// ---------------------------------------------------------------
// Get the event flag information associated with the current log.
// ---------------------------------------------------------------
int eventCount = (short)foundEventRecordList.Count;
int maxEventCount = log.MaxEventsPerTask * log.MaxTasks;
// Initialize the validFlags array to define which of the events are used in the current log.
short[] validFlags = new short[maxEventCount];
int eventIndex;
for (int index = 0; index < foundEventRecordList.Count; index++)
{
eventIndex = foundEventRecordList[index].TaskIdentifier * log.MaxEventsPerTask + foundEventRecordList[index].EventIdentifier;
validFlags[eventIndex] = CommonConstants.True;
}
short[] enabledFlags = new short[eventCount];
short[] streamTriggeredFlags = new short[eventCount];
try
{
CommunicationInterface.GetFltFlagInfo(validFlags, ref enabledFlags, ref streamTriggeredFlags, (short)maxEventCount);
}
catch (Exception)
{
throw new CommunicationException(Resources.EMGetFltFlagInfoFailed);
}
// ---------------------------------
// Initialise the event status list.
// ---------------------------------
m_EventStatusList = new List <EventStatus_t>(eventCount);
EventStatus_t eventStatus;
for (int eventStatusIndex = 0; eventStatusIndex < eventCount; eventStatusIndex++)
{
eventStatus = new EventStatus_t();
eventStatus.Index = eventStatusIndex;
eventStatus.Identifier = foundEventRecordList[eventStatusIndex].Identifier;
if (enabledFlags[eventStatusIndex] == CommonConstants.True)
{
eventStatus.Enabled = true;
}
if (streamTriggeredFlags[eventStatusIndex] == CommonConstants.True)
{
eventStatus.StreamTriggered = true;
}
m_EventStatusList.Add(eventStatus);
}
AddList(m_EventStatusList);
}
/// <summary>
/// Initialize a new instance of the class and set the properties and member variables to those values associated with the specified communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be used to
/// initialize the class.</param>
public CommunicationApplicationOffline(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
}
/// <summary>
/// Initialize a new instance of the class and set the function delegates, properties and member variables.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to
/// be used to initialize the class.</param>
public CommunicationParent(ICommunicationParent communicationInterface)
: this()
{
m_CommunicationSetting = communicationInterface.CommunicationSetting;
}
/// <summary>
/// Initialize a new instance of the class and set the properties and member variables to those values associated with the specified
/// communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationApplication(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
}
/// <summary>
/// Initialize a new instance of the class and set the function delegates, properties and member variables to those values associated with the
/// specified communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationWatch(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
}
/// <summary>
/// Clean up the resources used by the form.
/// </summary>
/// <param name="disposing">True to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected virtual void Cleanup(bool disposing)
{
this.Cursor = Cursors.WaitCursor;
try
{
// Provided that the form isn't minimized, update the WindowState setting.
if (this.WindowState != FormWindowState.Minimized)
{
Settings.Default.WindowState = this.WindowState;
Settings.Default.Save();
}
// If the WindowState property is normal, update the: Location and Size settings.
if (this.WindowState == FormWindowState.Normal)
{
Settings.Default.FormLocation = this.Location;
Settings.Default.FormSize = this.Size;
Settings.Default.Save();
}
CloseChildForms();
DebugMode.Close();
WinHlp32.Close(this.Handle.ToInt32());
// Ensure that the communication port is closed.
if (m_CommunicationInterface != null)
{
CommunicationInterface.CloseCommunication(CommunicationInterface.CommunicationSetting.Protocol);
}
if (disposing)
{
// Method called by consumer code. Call the Dispose method of any managed data members that implement the dispose method.
// Cleanup managed objects by calling their Dispose() methods.
if (components != null)
{
components.Dispose();
}
if (m_DataDictionary != null)
{
m_DataDictionary.Dispose();
}
if (m_ControlPanel != null)
{
m_ControlPanel.Dispose();
}
if (m_TimerWibuBox != null)
{
m_TimerWibuBox.Stop();
m_TimerWibuBox.Enabled = false;
m_TimerWibuBox.Tick -= new EventHandler(WibuBoxCheck);
m_TimerWibuBox.Dispose();
}
}
// Whether called by consumer code or the garbage collector free all unmanaged resources and set the value of managed data
// members to null.
m_DataDictionary = null;
m_TimerWibuBox = null;
m_ControlPanel = null;
m_CommunicationInterface = null;
m_MenuInterfaceApplication = null;
m_MenuInterfaceEvent = null;
m_MenuInterfaceSelfTest = null;
m_MenuInterfaceWatch = null;
m_MenuInterfaceWibuKey = null;
m_Security = null;
}
catch (Exception)
{
// Don't do anything, just ensure that an exception is not thrown.
}
this.Cursor = Cursors.Default;
}
/// <summary>
/// Initialize a new instance of the class
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be
/// used to initialize the class.</param>
public CommunicationSelfTest(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
m_SelfTestMarshal = new SelfTestMarshal(communicationInterface.CommDevice);
}
/// <summary>
/// Initialize a new instance of the class and set the properties and member variables to those values associated with the specified communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be used to
/// initialize the class.</param>
public CommunicationEventOffline(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
// --------------------------------------------------------------------------------------------
// Get the workset that is to be used to simulate the fault log parameters and the data stream.
// --------------------------------------------------------------------------------------------
// If it has been configured, get the first valid workset other than the baseline workset; otherwise, use the baseline workset.
int worksetIndex = (Workset.FaultLog.Worksets.Count > 0) ? 1 : 0;
Workset_t workset = Workset.FaultLog.Worksets[worksetIndex];
m_Workset = workset;
}
/// <summary>
/// Initialize a new instance of the class and set the function delegates, properties and member variables to those values associated with the
/// specified communication interface.
/// </summary>
/// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to
/// be used to initialize the class.</param>
public CommunicationEvent(ICommunicationParent communicationInterface)
: base(communicationInterface)
{
m_EventStreamMarshal = new EventStreamMarshal(communicationInterface.CommDevice);
}
