/// <summary>
/// Event handler for the 'Copy' context menu option <c>Click</c> event. Copies an existing workset.
/// </summary>
/// <param name="sender">Reference to the object that raised the event.</param>
/// <param name="e">Parameter passed from the object that raised the event.</param>
private void m_ContextMenuItemCopy_Click(object sender, EventArgs e)
{
// Skip, if the Dispose() method has been called.
if (IsDisposed)
{
return;
}
Cursor = Cursors.WaitCursor;
// Local reference to the selected item.
WorksetItem selectedItem = new WorksetItem();
// The index value of the selected workset.
int selectedIndex;
try
{
selectedItem = (WorksetItem)m_ListView.SelectedItems[0];
selectedIndex = m_ListView.SelectedIndices[0];
}
catch (Exception)
{
selectedItem = null;
selectedIndex = 0;
}
finally
{
Cursor = Cursors.Default;
}
// Check that an item has been selected.
if (selectedItem == null)
{
MessageBox.Show(Resources.MBTInstructionSelectWorkset, Resources.MBCaptionWarning, MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
Cursor = Cursors.WaitCursor;
// Create a temporary workset.
Workset_t copyOfWorkset = new Workset_t();
copyOfWorkset.Replicate(selectedItem.Workset);
// Override the security level to be the security level of the current user.
copyOfWorkset.SecurityLevel = Security.SecurityLevelCurrent;
// Override the name of the workset.
copyOfWorkset.Name = selectedItem.Workset.Name + CommonConstants.BindingMessage + Resources.TextCopy;
m_WorksetCollection.Add(copyOfWorkset);
Cursor = Cursors.Default;
// Save the modified object to disk.
Save();
UpdateListView();
}
/// <summary>
/// For the specified workset file update: (a) the baseline workset; (b) the WatchItems, WatchElementList and CountMax properties of all other worksets and (c)
/// the EntryCountMax field to be compatible with the new data dictionary. Also report any worksets that: (a) contain more watch values than are permitted
/// or (b) include one or more invalid old identifier references.
/// </summary>
/// <param name="worksetCollectionFile">The structure containing the de-serialized workset file.</param>
private void Update(ref WorksetCollectionFile_t worksetCollectionFile)
{
// Get the number of watch variables and the number of oldIdentifiers associated with the current data dictionary and the data dictionary associated with
// the workset.
int dataDictionaryOldIdentifierCount = Lookup.WatchVariableTableByOldIdentifier.RecordList.Count;
int dataDictionaryWatchIdentifierCount = Lookup.WatchVariableTable.RecordList.Count;
int worksetOldIdentifierCount = worksetCollectionFile.WorksetList[0].WatchItems.Length;
int worksetWatchIdentifierCount = 0;
for (int elementIndex = 0; elementIndex < worksetOldIdentifierCount; elementIndex++)
{
if (worksetCollectionFile.WorksetList[0].WatchItems[elementIndex].Exists == true)
{
worksetWatchIdentifierCount++;
}
}
int watchVariablesAddedTo = 0;
int watchVariablesDeletedFrom = 0;
if (dataDictionaryOldIdentifierCount > worksetOldIdentifierCount)
{
watchVariablesAddedTo = dataDictionaryOldIdentifierCount - worksetOldIdentifierCount;
watchVariablesDeletedFrom = watchVariablesAddedTo - (dataDictionaryWatchIdentifierCount - worksetWatchIdentifierCount);
}
else if (worksetOldIdentifierCount > dataDictionaryOldIdentifierCount)
{
watchVariablesDeletedFrom = worksetOldIdentifierCount - dataDictionaryOldIdentifierCount;
watchVariablesAddedTo = watchVariablesDeletedFrom - (worksetWatchIdentifierCount - dataDictionaryWatchIdentifierCount);
}
// Check whether the WatchItems property of the worksets in the specified workset collection need be updated i.e. check whether any watch variables have been
// added to or deleted from the the data dictionary since the workset was created.
List<short> invalidOldIdentifierList;
List<Workset_t> invalidOldIdentifierWorksetList, invalidWatchSizeWorksetList;
if ((dataDictionaryOldIdentifierCount != worksetOldIdentifierCount) ||
(dataDictionaryWatchIdentifierCount != worksetWatchIdentifierCount))
{
#region - [Error Reporting] -
// Check whether any watch variables have been deleted from the current data dictionary since the worksets were defined.
if (watchVariablesDeletedFrom > 0)
{
// Yes - Get a list of any old identifiers in the workset file that are incompatible with the current data dictionary.
invalidOldIdentifierList = GetIncompatibleOldIdentifierList(worksetCollectionFile);
if (invalidOldIdentifierList.Count > 0)
{
// Get the list of worksets that are effected.
invalidOldIdentifierWorksetList = GetIncompatibleWorksetList(worksetCollectionFile, invalidOldIdentifierList);
if (invalidOldIdentifierWorksetList.Count > 0)
{
ReportIncompatibleWorksets(invalidOldIdentifierWorksetList, invalidOldIdentifierList, worksetCollectionFile.WorksetCollectionType);
}
}
}
#endregion - [Error Reporting] -
#region - [WatchItems/WatchElementList Update] -
// ------------------------------------------------------------------------------------
// Update the WatchItems and WatchElementList fields of all of the workset in the file.
// ------------------------------------------------------------------------------------
for (short worksetIndex = 0; worksetIndex < worksetCollectionFile.WorksetList.Count; worksetIndex++)
{
// Replicate the workset.
Workset_t workset = new Workset_t();
workset.Replicate(worksetCollectionFile.WorksetList[worksetIndex]);
//Create a new WatchItems propery for the current workset based upon the current data dictionary with the Added property of all elements set to false.
workset.WatchItems = new WatchItem_t[dataDictionaryOldIdentifierCount];
WatchItem_t watchItem;
for (short watchItemIndex = 0; watchItemIndex < dataDictionaryOldIdentifierCount; watchItemIndex++)
{
watchItem = new WatchItem_t();
watchItem.OldIdentifier = watchItemIndex;
watchItem.Added = false;
try
{
// Check whether the watch variable exists and set the Exists property of the watch item appropriately.
WatchVariable watchVariable = Lookup.WatchVariableTableByOldIdentifier.Items[watchItemIndex];
watchItem.Exists = (watchVariable == null) ? false : true;
}
catch (Exception)
{
watchItem.Exists = false;
}
workset.WatchItems[watchItemIndex] = watchItem;
}
// Update the WatchElementList and the WatchItems properties of the workset using the old identifier values stored in each column of the workset.
workset.WatchElementList = new List<short>();
short oldIdentifier;
for (int columnIndex = 0; columnIndex < workset.Column.Length; columnIndex++)
{
for (int rowIndex = 0; rowIndex < workset.Column[columnIndex].OldIdentifierList.Count; rowIndex++)
{
// Get the old identifier value.
oldIdentifier = workset.Column[columnIndex].OldIdentifierList[rowIndex];
// Check whether the watch variable associated with the old identifier value exists in the current workset.
try
{
WatchVariable watchVariable = Lookup.WatchVariableTableByOldIdentifier.Items[oldIdentifier];
if (watchVariable == null)
{
// No, add the watch identifier value used to represent the watch variable not being defined in the current data dictionary.
workset.WatchElementList.Add(CommonConstants.WatchIdentifierNotDefined);
}
else
{
// Add the watch identifier of the watch variable corresponding to the specified old identifier to the list of watch identifiers.
workset.WatchElementList.Add(watchVariable.Identifier);
// Update the Exists and Added properties of the WatchItem element corresponding to the specified old identifier.
workset.WatchItems[oldIdentifier].Added = true;
workset.WatchItems[oldIdentifier].Exists = true;
}
}
catch (Exception)
{
// No, add the watch identifier value used to represent the watch variable not being defined in the current data dictionary.
workset.WatchElementList.Add(CommonConstants.WatchIdentifierNotDefined);
}
}
}
workset.WatchElementList.Sort();
// Replace the workset.
worksetCollectionFile.WorksetList[worksetIndex] = workset;
#endregion - [WatchItems/WatchElementList Update] -
}
}
// Only carry out watch size processing if the workset collection corresponds to a watch window workset.
if (worksetCollectionFile.WorksetCollectionType == Configuration.WorksetCollectionType.RecordedWatch)
{
#region - [Error Reporting] -
invalidWatchSizeWorksetList = GetIncompatibleWorksetList(worksetCollectionFile, Parameter.WatchSize);
if (invalidWatchSizeWorksetList.Count > 0)
{
ReportIncompatibleWorksets(invalidWatchSizeWorksetList);
}
#endregion - [Error Reporting] -
#region - [WatchSize Update] -
// Update the EntryCountMax field of the workset file, if required.
if (worksetCollectionFile.EntryCountMax != Parameter.WatchSize)
{
worksetCollectionFile.EntryCountMax = Parameter.WatchSize;
}
// Update the baseline workset and the EntryCount max field of individual worksets, if required.
for (int worksetIndex = 0; worksetIndex < worksetCollectionFile.WorksetList.Count; worksetIndex++)
{
Workset_t workset;
if (worksetCollectionFile.WorksetList[worksetIndex].CountMax != Parameter.WatchSize)
{
// If the workset is the baseline workset, update it.
if (worksetIndex == 0)
{
workset = CreateBaselineWorkset();
}
else
{
workset = worksetCollectionFile.WorksetList[worksetIndex];
workset.CountMax = Parameter.WatchSize;
}
worksetCollectionFile.WorksetList[worksetIndex] = workset;
}
}
#endregion - [WatchSize Update] -
}
}
/// <summary>
/// Convert the current user setting to a workset.
/// </summary>
/// <param name="worksetName">The name of the workset.</param>
/// <returns>The user settings converted to a workset.</returns>
private Workset_t ConvertToWorkset(string worksetName)
{
Workset_t workset = new Workset_t();
workset.Replicate(m_Workset);
// This attribute is used to define the plot screen layout and is defined by the user when displaying the saved data file.
workset.PlotTabPages = new PlotTabPage_t[workset.Column.Length];
for (int tabPageindex = 0; tabPageindex < workset.Column.Length; tabPageindex++)
{
workset.PlotTabPages[tabPageindex].HeaderText = m_TextBoxHeaders[tabPageindex].Text;
workset.PlotTabPages[tabPageindex].OldIdentifierList = new List<short>();
workset.PlotTabPages[tabPageindex].DisplayMaskList = new List<uint>();
for (int index = 0; index < m_ListBoxes[tabPageindex].Items.Count; index++)
{
workset.PlotTabPages[tabPageindex].OldIdentifierList.Add(((WatchItem_t)m_ListBoxes[tabPageindex].Items[index]).OldIdentifier);
workset.PlotTabPages[tabPageindex].DisplayMaskList.Add(((WatchItem_t)m_ListBoxes[tabPageindex].Items[index]).DisplayMask);
}
}
return workset;
}
