/// <summary>
/// Selects the next node whose error level corresponds to the levelEnum provided
/// </summary>
/// <param name="current">the model element that is currently displayed</param>
/// <param name="node">the node from which the selection process must begin</param>
/// <param name="levelEnum"></param>
/// <param name="considerThisOne">Indicates that the current node should be considered by the search</param>
/// <returns>the node to select</returns>
private BaseTreeNode RecursivelySelectNext(Utils.IModelElement current, BaseTreeNode node, Utils.ElementLog.LevelEnum levelEnum, bool considerThisOne)
{
BaseTreeNode retVal = null;
if (considerThisOne)
{
if (node.Model.HasMessage(levelEnum) && node.Model != current)
{
retVal = node;
}
}
if (retVal == null)
{
if (node.Nodes.Count > 0)
{
foreach (BaseTreeNode subNode in node.Nodes)
{
retVal = RecursivelySelectNext(current, subNode, levelEnum, true);
if (retVal != null)
{
break;
}
}
}
}
return(retVal);
}
/// <summary>
/// Removes useless prefixes from the string provided
/// </summary>
/// <param name="fullName"></param>
/// <param name="model"></param>
/// <returns></returns>
private string StripUseless(string fullName, Utils.IModelElement model)
{
string retVal = fullName;
if (model != null)
{
char[] tmp = fullName.ToArray();
char[] modelName = model.FullName.ToArray();
int i = 0;
while (i < tmp.Length && i < modelName.Length)
{
if (tmp[i] != modelName[i])
{
break;
}
i += 1;
}
retVal = retVal.Substring(i);
if (Utils.Utils.isEmpty(retVal))
{
retVal = model.Name;
}
}
if (retVal.StartsWith(DEFAULT_PREFIX))
{
retVal = retVal.Substring(DEFAULT_PREFIX.Length);
}
return(retVal);
}
/// <summary>
/// Selects the next node whose error level corresponds to the levelEnum provided
/// </summary>
/// <param name="levelEnum"></param>
public void SelectNext(Utils.ElementLog.LevelEnum levelEnum)
{
BaseTreeNode node = Selected;
BaseTreeNode toSelect = null;
if (node != null)
{
Utils.IModelElement current = node.Model;
toSelect = RecursivelySelectNext(current, node, levelEnum, false);
while (toSelect == null && node != null)
{
while (node != null && node.NextNode == null)
{
node = node.Parent as BaseTreeNode;
}
if (node != null)
{
node = node.NextNode as BaseTreeNode;
toSelect = RecursivelySelectNext(current, node, levelEnum, true);
}
}
}
else
{
toSelect = RecursivelySelectNext(null, Nodes[0] as BaseTreeNode, levelEnum, true);
}
Selected = toSelect;
}
public StandardValuesCollection GetValues(Utils.IModelElement element)
{
Utils.FinderRepository.INSTANCE.ClearCache();
DataDictionary.Dictionary dictionary = Utils.EnclosingFinder <DataDictionary.Dictionary> .find(element);
DataDictionary.Types.NameSpace nameSpace = DataDictionary.EnclosingNameSpaceFinder.find(element);
List <string> retVal = new List <string>();
if (nameSpace != null)
{
DataDictionary.OverallTypeFinder.INSTANCE.findAllValueNames("", nameSpace, true, retVal);
}
else
{
DataDictionary.OverallTypeFinder.INSTANCE.findAllValueNames("", dictionary, false, retVal);
}
retVal.Sort();
foreach (string name in dictionary.EFSSystem.PredefinedTypes.Keys)
{
retVal.Add(name);
}
return(new StandardValuesCollection(retVal));
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Range item = element as Range;
if (item != null)
{
appendRanges(item);
}
}
{
Enum item = element as Enum;
if (item != null)
{
appendEnumerations(item);
}
}
{
Structure item = element as Structure;
if (item != null)
{
appendStructures(item);
}
}
{
Collection item = element as Collection;
if (item != null)
{
appendCollections(item);
}
}
{
Functions.Function item = element as Functions.Function;
if (item != null)
{
appendFunctions(item);
}
}
{
Functions.Procedure item = element as Functions.Procedure;
if (item != null)
{
appendProcedures(item);
}
}
{
Rules.Rule item = element as Rules.Rule;
if (item != null)
{
appendRules(item);
}
}
{
Variables.Variable item = element as Variables.Variable;
if (item != null)
{
appendVariables(item);
}
}
}
/// <summary>
/// Compares two values
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public int CompareTo(Utils.IModelElement other)
{
if (this == other)
{
return(0);
}
return(-1);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
SubStep item = element as SubStep;
if (item != null)
{
appendSubSteps(item);
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
ReqRef reqRef = element as ReqRef;
if (reqRef != null)
{
appendRequirements(reqRef);
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
SubStep subStep = element as SubStep;
if (subStep != null)
{
appendSubSteps(subStep);
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
TestCase item = element as TestCase;
if (item != null)
{
appendTestCases(item);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
SubSequence item = element as SubSequence;
if (item != null)
{
appendSubSequences(item);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Chapter item = element as Chapter;
if (item != null)
{
appendChapters(item);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Paragraph item = element as Paragraph;
if (item != null)
{
appendParagraphs(item);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public void AddModelElement(Utils.IModelElement element)
{
{
Dictionary item = element as Dictionary;
if (item != null)
{
Dictionaries.Add(item);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Rules.PreCondition item = element as Rules.PreCondition;
if (item != null)
{
appendPreConditions(item);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Constants.EnumValue item = element as Constants.EnumValue;
if (item != null)
{
appendSpecialValues(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Step item = element as Step;
if (item != null)
{
appendSteps(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Provides the node which corresponds to the model element provided
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public BaseTreeNode FindNode(Utils.IModelElement model)
{
BaseTreeNode retVal = null;
foreach (BaseTreeNode node in Nodes)
{
retVal = InnerFindNode(node, model);
if (retVal != null)
{
break;
}
}
return(retVal);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
ShortcutFolder folder = element as ShortcutFolder;
if (folder != null)
{
appendFolders(folder);
}
else
{
Shortcut shortcut = element as Shortcut;
if (shortcut != null)
{
appendShortcuts(shortcut);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
Folder folder = element as Folder;
if (folder != null)
{
appendFolders(folder);
}
else
{
Translation translation = element as Translation;
if (translation != null)
{
appendTranslations(translation);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
if (element is Rules.Action)
{
Rules.Action item = element as Rules.Action;
if (item != null)
{
appendActions(item);
}
}
else if (element is Expectation)
{
Tests.Expectation item = element as Tests.Expectation;
if (item != null)
{
appendExpectations(item);
}
}
}
/// <summary>
/// Selects the node which references the element provided
/// </summary>
/// <param name="element"></param>
/// <param name="getFocus">Indicates whether the focus should be given to the enclosing form</param>
/// <returns>the selected node</returns>
public BaseTreeNode Select(Utils.IModelElement element, bool getFocus = false)
{
BaseTreeNode retVal = null;
retVal = FindNode(element);
if (retVal != null)
{
Selected = retVal;
if (getFocus)
{
Form form = GUIUtils.EnclosingFinder <Form> .find(this);
form.BringToFront();
}
}
return(retVal);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
PreCondition item = element as PreCondition;
if (item != null)
{
appendPreConditions(item);
}
}
{
Action item = element as Action;
if (item != null)
{
appendActions(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Constants.State item = element as Constants.State;
if (item != null)
{
appendStates(item);
}
}
{
Rules.Rule item = element as Rules.Rule;
if (item != null)
{
appendRules(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Finds the node which references the element provided
/// </summary>
/// <param name="node"></param>
/// <param name="element"></param>
/// <returns></returns>
private BaseTreeNode InnerFindNode(BaseTreeNode node, Utils.IModelElement element)
{
BaseTreeNode retVal = null;
if (node.Model == element)
{
retVal = node;
}
else
{
foreach (BaseTreeNode subNode in node.Nodes)
{
retVal = InnerFindNode(subNode, element);
if (retVal != null)
{
break;
}
}
}
return(retVal);
}
/// <summary>
/// Finds the tree node which corresponds to the model element
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public BaseTreeNode FindNode(Utils.IModelElement model)
{
return(TreeView.FindNode(model));
}
/// <summary>
/// Sets the model for this explain text box
/// </summary>
/// <param name="model"></param>
public void SetModel(Utils.IModelElement model)
{
Model = model;
RefreshData();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="action"The action which raised the variable update></param>
public VariableUpdate(Rules.Action action, Utils.IModelElement instance)
: base(action.Statement.ToString(), instance)
{
Action = action;
}
/// <summary>
/// Sets the root of this tree view
/// </summary>
/// <param name="Model"></param>
public override void SetRoot(Utils.IModelElement Model)
{
Root = Model as RootType;
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
base.AddModelElement(element);
}
