//******************************************************************
/// <summary>
/// Adds a new item to the list of rules. The item is placed in edit
/// mode so the user can rename the new rule.
/// </summary>
public void AddNewRule()
{
//**************************************************************
// Validate the current state.
if (! CanAddNewRule())
{
string sMessage = "Invalid state: "
+ "A call to RuleListViewer.AddNewRule() is not "
+ "allowed if RuleListViewer.CanAddNewRule() returns "
+ "false.";
throw new Exception(sMessage);
}
//**************************************************************
// Prevent modification to a read-only list.
if (ReadOnly)
{
return;
}
//**************************************************************
// Set the Modified property to true.
//
// If the list is empty and Modified is false, adding a blank
// new rule does not set Modified to true. (Modified will be set
// to true later if the user makes any changes to the blank new
// rule, or if the user makes any other changes to the list.)
if (moListView.Items.Count > 0)
{
Modified = true;
}
//**************************************************************
// Clear the selection.
ClearSelection();
//**************************************************************
// Clear the linked FindPatternViewer and ReplacePatternViewer.
UpdateFindAndReplacePatternViewers(null);
//**************************************************************
// Reset the TreeTransferData object.
ResetTreeTransferData();
//**************************************************************
// Clear the undo information.
ClearUndoInformation();
//**************************************************************
// Create a new rule item and append it to the list.
RuleListViewerItem oRuleItem = new RuleListViewerItem();
oRuleItem.Text = "(new rule)";
oRuleItem.FindPatternRoot = new SyntaxNode();
oRuleItem.ReplacePatternRoot = new SyntaxNode();
moListView.Items.Add(oRuleItem);
//**************************************************************
// Select the item. Make sure it is scrolled into view and has
// focus within the ListView.
oRuleItem.Selected = true;
oRuleItem.EnsureVisible();
oRuleItem.Focused = true;
//**************************************************************
// Raise the SelectionChanged event.
OnSelectionChanged(new EventArgs());
//**************************************************************
// Raise the ListChanged event.
OnListChanged(new EventArgs());
//**************************************************************
// Place the item in edit mode so the user can edit the name of
// the new rule. (If the user changes the rule name, the
// AfterLabelEdit event handler will raise the ListChanged
// event again.)
oRuleItem.BeginEdit();
}
//******************************************************************
/// <summary>
/// Uses the .FindPatternRoot and .ReplacePatternRoot properties of
/// the given oSelectedRule object to populate the linked
/// FindPatternViewer and ReplacePatternViewer. The SelectedRule
/// property is set to the given oSelectedRule object.
/// </summary>
private void UpdateFindAndReplacePatternViewers(
RuleListViewerItem oSelectedRule)
{
//**************************************************************
// Use the given oSelectedRule to initialize a TreeTransfer
// object, which will be used to populate the find-pattern and
// replace-pattern viewers.
//
// If oSelectedRule is null, blank nodes will be used to
// populate the find-pattern and replace-pattern viewers.
//
// If oSelectedRule is not null, its .FindPatternRoot tree and
// .ReplacePatternRoot tree will be used to populate the
// find-pattern and replace-pattern viewers.
TreeTransfer oTreeTransfer = new TreeTransfer();
if (oSelectedRule == null)
{
oTreeTransfer.ParseTreeRoot = null;
oTreeTransfer.FindPatternRoot = new SyntaxNode();
oTreeTransfer.ReplacePatternRoot = new SyntaxNode();
}
else
{
oTreeTransfer.ParseTreeRoot = null;
oTreeTransfer.FindPatternRoot
= oSelectedRule.FindPatternRoot;
oTreeTransfer.ReplacePatternRoot
= oSelectedRule.ReplacePatternRoot;
}
//**************************************************************
// Temporarily set the SelectedRule property to null, because we
// do not want the LinkedFindPatternViewer TreeChanged event and
// the LinkedReplacePatternViewer TreeChanged event to update
// the SelectedRule (and set the Modified property to true) when
// we populate the find-pattern and replace-pattern trees.
moSelectedRule = null;
//**************************************************************
// Populate the linked find-pattern viewer.
if (LinkedFindPatternViewer != null)
{
LinkedFindPatternViewer.PopulateTree(oTreeTransfer);
}
//**************************************************************
// Populate the linked replace-pattern viewer.
if (LinkedReplacePatternViewer != null)
{
LinkedReplacePatternViewer.PopulateTree(oTreeTransfer);
}
//**************************************************************
// Now set the SelectedRule property to the given oSelectedRule
// object, because we want the TreeChanged events to update the
// SelectedRule (and set the Modified property to true) when the
// user edits the find-pattern and replace-pattern trees.
moSelectedRule = oSelectedRule;
}
//******************************************************************
/// <summary>
/// Inserts the given rules (oTransferRules) into the ListView,
/// starting at the indicated index (iFirstIndex). The inserted
/// rules are selected.
/// </summary>
private void InsertRules(int iFirstIndex,
TransferRuleCollection oTransferRules)
{
Debug.Assert(iFirstIndex >= 0);
Debug.Assert(oTransferRules != null);
Debug.Assert(oTransferRules.Count > 0);
//**************************************************************
// Clear the selection.
ClearSelection();
//**************************************************************
// Insert the given rules starting at the indicated index.
int iIndex = iFirstIndex;
foreach (TransferRule oRule in oTransferRules)
{
//**********************************************************
// Create the item to display in the ListView.
RuleListViewerItem oRuleItem = new RuleListViewerItem();
oRuleItem.Text = oRule.RuleName;
oRuleItem.FindPatternRoot = oRule.FindPatternRoot;
oRuleItem.ReplacePatternRoot = oRule.ReplacePatternRoot;
//**********************************************************
// Insert or append the item in the ListView.
if (iIndex < moListView.Items.Count)
{
moListView.Items.Insert(iIndex,oRuleItem);
}
else
{
moListView.Items.Add(oRuleItem);
}
//**********************************************************
// Select the item and make sure it is scrolled into view.
oRuleItem.Selected = true;
oRuleItem.EnsureVisible();
//**********************************************************
// Increment the index.
++iIndex;
}
//**************************************************************
// Make sure the first selected item is scrolled into view and
// has focus within the ListView.
RuleListViewerItem oFirstSelectedItem = FirstSelectedItem();
if (oFirstSelectedItem != null)
{
oFirstSelectedItem.EnsureVisible();
oFirstSelectedItem.Focused = true;
}
}
//******************************************************************
/// <summary>
/// Makes sure a rule is selected when the input focus leaves this
/// control.
/// </summary>
private void RuleListViewer_Leave(object oSender,EventArgs oArgs)
{
try
{
//**********************************************************
// If the list is empty (and not read-only), add a new rule
// to the list and select it.
if (moListView.Items.Count == 0)
{
if (! ReadOnly)
{
//**************************************************
// Set the Modified property to true.
Modified = true;
//**************************************************
// Reset the TreeTransferData object.
ResetTreeTransferData();
//**************************************************
// Clear the undo information.
ClearUndoInformation();
//**************************************************
// Create a new rule item and append it to the list.
RuleListViewerItem oRuleItem
= new RuleListViewerItem();
oRuleItem.Text = "(new rule)";
oRuleItem.FindPatternRoot = new SyntaxNode();
oRuleItem.ReplacePatternRoot = new SyntaxNode();
moListView.Items.Add(oRuleItem);
//**************************************************
// Select the item.
oRuleItem.Selected = true;
//**************************************************
// Raise the ListChanged event.
OnListChanged(new EventArgs());
}
}
//**********************************************************
// If the list is not empty, one of the items should be the
// SelectedRule.
if (moListView.Items.Count > 0)
{
Debug.Assert(SelectedRule != null);
Debug.Assert(moListView.Items.Contains(SelectedRule));
}
//**********************************************************
// Make sure the SelectedRule item is selected.
if (SelectedRule != null)
{
if (SelectedRule != FirstSelectedItem())
{
ClearSelection();
SelectedRule.Selected = true;
}
}
//**********************************************************
// Make sure the SelectedRule item is scrolled into view and
// has focus within the ListView.
if (SelectedRule != null)
{
SelectedRule.EnsureVisible();
SelectedRule.Focused = true;
}
}
catch (Exception oException)
{
ShowException(oException);
}
}
//******************************************************************
/// <summary>
/// Loads and displays the indicated rule file (sFileName). The
/// Modified property is set to false after the file is loaded.
/// </summary>
public void LoadRuleFile(string sFileName)
{
//**************************************************************
// Validate the parameters.
if ((sFileName == null) || (sFileName == ""))
{
string sMessage = "Invalid argument: "
+ "RuleListViewer.LoadRuleFile() requires "
+ "a file name that is not null or blank.";
throw new Exception(sMessage);
}
//**************************************************************
// Clear the linked FindPatternViewer and ReplacePatternViewer.
UpdateFindAndReplacePatternViewers(null);
//**************************************************************
// Reset the TreeTransferData object.
ResetTreeTransferData();
//**************************************************************
// Clear the undo information.
ClearUndoInformation();
//**************************************************************
// Clear the list of items in the ListView.
moListView.Items.Clear();
//**************************************************************
// Create a RuleReader to read from the indicated rule file.
StreamReader oStreamReader = new StreamReader(sFileName);
RuleReader oRuleReader = new RuleReader(oStreamReader);
//**************************************************************
// For each rule loaded from the rule file, create a new rule
// item and append it to the ListView.
while (oRuleReader.Read())
{
RuleListViewerItem oRuleItem = new RuleListViewerItem();
oRuleItem.Text
= oRuleReader.RuleName;
oRuleItem.FindPatternRoot
= oRuleReader.FindPatternRoot;
oRuleItem.ReplacePatternRoot
= oRuleReader.ReplacePatternRoot;
moListView.Items.Add(oRuleItem);
}
//**************************************************************
// Close the RuleReader.
oRuleReader.Close();
//**************************************************************
// Select the first item in the ListView. Make sure it is
// scrolled into view and has focus within the ListView.
if (moListView.Items.Count > 0)
{
ListViewItem oItem = moListView.Items[0];
oItem.Selected = true;
oItem.EnsureVisible();
oItem.Focused = true;
}
//**************************************************************
// Set the Modified property to false.
Modified = false;
//**************************************************************
// Raise the SelectionChanged event.
OnSelectionChanged(new EventArgs());
//**************************************************************
// Raise the ListChanged event.
OnListChanged(new EventArgs());
}
