/// <summary>
/// Sets the state machine variable (and type)
/// </summary>
/// <param name="stateMachine">The state machine variable to display</param>
/// <param name="stateMachineType">
/// The state machine type which should be displayed. If null, the default state machine is
/// displayed
/// </param>
public void SetStateMachine(IVariable stateMachine, StateMachine stateMachineType = null)
{
if (stateMachineType == null)
{
stateMachineType = stateMachine.Type as StateMachine;
}
if (stateMachineType != null)
{
Model = stateMachineType;
}
Model = Model;
if (stateMachine != null)
{
StateMachineVariableExpression =
new Parser().Expression(EnclosingFinder <Dictionary> .find(stateMachine),
stateMachine.FullName);
}
else
{
StateMachineVariableExpression = null;
}
RefreshControl();
}
/// <summary>
/// Removes the prefix according to the StartRemove and EndRemove values
/// </summary>
/// <param name="treeNode">The tree node to replace</param>
/// <param name="referencedElement">The element that should be replaced</param>
/// <returns>if the replacement has been done</returns>
private bool ReplaceNonTerminal(InterpreterTreeNode treeNode, ModelElement referencedElement)
{
bool retVal;
if (ReplaceAllReferences)
{
// Only do the repleacement for elements defined in a dictionary
retVal = EnclosingFinder <Dictionary> .find(referencedElement) != null;
}
else
{
// Check that the reference corresponds to the specific reference for this visitor
retVal = referencedElement == Ref;
}
if (retVal)
{
// Removes the prefix
if (ShouldRemovePrefix)
{
ReplaceText("", StartRemove, EndRemove);
ResetRemoveIndexes();
}
string replacementValue = referencedElement.ReferenceName(User);
ReplaceText(replacementValue, treeNode.Start, treeNode.End);
}
return(retVal);
}
/// <summary>
/// Allows to refresh the view, when the value of a model changed
/// </summary>
/// <param name="modelElement"></param>
/// <param name="changeKind"></param>
/// <returns>True if the view should be refreshed</returns>
public override bool HandleValueChange(IModelElement modelElement, Context.ChangeKind changeKind)
{
bool retVal = base.HandleValueChange(modelElement, changeKind);
if (retVal)
{
if (changeKind != Context.ChangeKind.EndOfCycle)
{
modelDiagramPanel.RefreshControl();
if (stateDiagramPanel != null)
{
stateDiagramPanel.RefreshControl();
}
Dictionary enclosing = EnclosingFinder <Dictionary> .find(modelElement, true);
if (modelElement == null || enclosing == Dictionary)
{
dataDictTree.RefreshModel(modelElement);
}
}
}
return(retVal);
}
/// <summary>
/// Updates (if possible) the initial state for this transition
/// </summary>
/// <param name="initialBox"></param>
public void SetInitialBox(IGraphicalDisplay initialBox)
{
State initialState = (State)initialBox;
if (Action != null)
{
if (PreCondition != null)
{
if (PreCondition.Rule == Action.Rule)
{
List <State> states = StateMachine.GetStates(PreCondition.Expression);
if (states.Count == 1)
{
PreCondition.ExpressionText = "THIS == " + initialState.FullName;
Source = initialState;
}
else
{
throw new CannotChangeRuleException("More than one state in the pre condition expression");
}
}
else
{
throw new CannotChangeRuleException("Precondition is not at the same level as the action");
}
}
else
{
RuleCondition ruleCondition = Action.Enclosing as RuleCondition;
if (ruleCondition != null)
{
Rule rule = ruleCondition.EnclosingRule;
if (EnclosingFinder <State> .find(rule) == Source)
{
if (rule.RuleConditions.Count == 1)
{
Source.StateMachine.removeRules(rule);
Source = initialState;
Source.StateMachine.appendRules(rule);
}
else
{
rule.removeConditions(ruleCondition);
Source = initialState;
Rule newRule = (Rule)acceptor.getFactory().createRule();
newRule.Name = rule.Name;
newRule.appendConditions(ruleCondition);
Source.StateMachine.appendRules(newRule);
}
}
else
{
throw new CannotChangeRuleException("Action is not defined directly in the state");
}
}
}
}
Source = initialState;
}
/// <summary>
/// Indicates that the arrow should be displayed in the DEDUCED color
/// </summary>
/// <returns></returns>
public override bool IsDeduced()
{
bool retVal = base.IsDeduced();
if (!retVal)
{
if (TypedModel.GraphicalName.CompareTo(Transition.InitialTransitionName) != 0)
{
StateMachine transitionStateMachine = EnclosingFinder <StateMachine> .find(TypedModel.RuleCondition);
if (transitionStateMachine == null)
{
// A deduced case is a arrow that is not defined in any state machine
retVal = true;
}
else
{
StatePanel panel = (StatePanel)Panel;
if (TypedModel.RuleCondition != null &&
panel.Model.Rules.Contains(TypedModel.RuleCondition.EnclosingRule))
{
// A deduced case is a arrow that is defined in the rules of the state machines (not in its states)
retVal = true;
}
}
}
}
return(retVal);
}
/// <summary>
/// The sub step relative to the mouse position
/// </summary>
/// <returns></returns>
private SubStep SubStepRelatedToMousePosition()
{
SubStep retVal = null;
ModelEvent evt = GetEventUnderMouse();
if (evt != null && evt.Instance != null)
{
retVal = EnclosingFinder <SubStep> .find(evt.Instance as IEnclosed, true);
if (retVal == null)
{
Step step = evt.Instance as Step;
if (step != null && step.SubSteps.Count > 0)
{
retVal = (SubStep)step.SubSteps[step.SubSteps.Count - 1];
}
}
}
if (retVal == null && Steps != null && Steps.Count > 0)
{
Step step = (Step)Steps[Steps.Count - 1];
if (step.SubSteps.Count > 0)
{
retVal = (SubStep)step.SubSteps[step.SubSteps.Count - 1];
}
}
return(retVal);
}
/// <summary>
/// Counts the issues and the blocking issues
/// </summary>
/// <param name="obj"></param>
/// <param name="visitSubNodes"></param>
public override void visit(Generated.ReferencesParagraph obj, bool visitSubNodes)
{
ReferencesParagraph referencesParagraph = obj as ReferencesParagraph;
if (referencesParagraph != null)
{
foreach (ReqRef reqRef in referencesParagraph.Requirements)
{
IssueKind?kind = IssueKindUtil.GetKind(reqRef.Paragraph);
if (kind != null)
{
Issues[(IssueKind)kind] += 1;
if (kind == IssueKind.Blocking)
{
SubSequence enclosingSubSequence = EnclosingFinder <SubSequence> .find(referencesParagraph,
true);
if (enclosingSubSequence != null)
{
BlockingSubSequences.Add(enclosingSubSequence);
}
}
}
}
}
base.visit(obj, visitSubNodes);
}
public StandardValuesCollection GetValues(IModelElement element)
{
FinderRepository.INSTANCE.ClearCache();
Dictionary dictionary = EnclosingFinder <Dictionary> .find(element);
NameSpace nameSpace = EnclosingNameSpaceFinder.find(element);
List <string> retVal = new List <string>();
if (nameSpace != null)
{
OverallTypeFinder.INSTANCE.findAllValueNames("", nameSpace, true, retVal);
}
else
{
OverallTypeFinder.INSTANCE.findAllValueNames("", dictionary, false, retVal);
}
retVal.Sort();
foreach (string name in dictionary.EFSSystem.PredefinedTypes.Keys)
{
retVal.Add(name);
}
return(new StandardValuesCollection(retVal));
}
/// <summary>
/// Update references to paragraphs
/// </summary>
/// <param name="obj"></param>
/// <param name="visitSubNodes"></param>
public override void visit(Generated.ReqRef obj, bool visitSubNodes)
{
ReqRef reqRef = (ReqRef)obj;
if (UpdateGuid)
{
Specification.Paragraph paragraph = reqRef.Paragraph;
if (paragraph != null)
{
// Updates the paragraph Guid
if (paragraph.Guid != reqRef.getId())
{
reqRef.setId(paragraph.getGuid());
}
// Updates the specification Guid
Specification.Specification specification =
EnclosingFinder <Specification.Specification> .find(paragraph);
if (specification.Guid != reqRef.getSpecId())
{
reqRef.setSpecId(specification.Guid);
}
}
}
base.visit(obj, visitSubNodes);
}
/// <summary>
/// Allows to refresh the view, when the value of a model changed
/// </summary>
/// <param name="modelElement"></param>
/// <param name="changeKind"></param>
/// <returns>True if the view should be refreshed</returns>
public override bool HandleValueChange(IModelElement modelElement, Context.ChangeKind changeKind)
{
bool retVal = base.HandleValueChange(modelElement, changeKind);
if (retVal)
{
if (Variable != null)
{
Expression expression = new Parser().Expression(
EnclosingFinder <Dictionary> .find(Variable), Variable.FullName);
IVariable variable = expression.GetVariable(new InterpretationContext());
if (variable != Variable)
{
SetVariable(variable);
}
else
{
structureTreeListView.RefreshObject(Variable);
structureTreeListView.Refresh();
}
}
}
return(retVal);
}
/// <summary>
/// Indicates that the model element should be displayed
/// </summary>
/// <param name="modelElement"></param>
/// <returns></returns>
protected override bool ShouldTrackSelectionChange(IModelElement modelElement)
{
bool retVal = base.ShouldTrackSelectionChange(modelElement);
if (retVal)
{
// Don't handle shortcuts in history
retVal = EnclosingFinder <ShortcutDictionary> .find(modelElement, true) == null;
}
return(retVal);
}
/// <summary>
/// Indicates that the model element should be displayed
/// </summary>
/// <param name="modelElement"></param>
/// <returns></returns>
protected override bool ShouldTrackSelectionChange(IModelElement modelElement)
{
bool retVal = base.ShouldTrackSelectionChange(modelElement);
if (retVal)
{
NameSpace nameSpace = EnclosingFinder <NameSpace> .find(modelElement, true);
retVal = nameSpace != null || modelElement == Dictionary;
}
return(retVal);
}
/// <summary>
/// Provides the description of the requirements related to this model element
/// </summary>
/// <returns></returns>
public virtual string RequirementDescription()
{
string retVal = "";
ReqRelated reqRelated = EnclosingFinder <ReqRelated> .find(this, true);
if (reqRelated != null)
{
retVal = reqRelated.RequirementDescription();
}
return(retVal);
}
/// <summary>
/// Provides the Namespace or the Dictionary enclosing the element in the context
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private static IModelElement DisplayedElementInModelDiagramPanel(Context.SelectionContext context)
{
IModelElement model = null;
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (model == null)
{
model = EnclosingFinder <Function> .find(context.Element, true);
}
if (model == null)
{
model = EnclosingFinder <RuleCondition> .find(context.Element, true);
}
if (model == null)
{
model = EnclosingFinder <Rule> .find(context.Element, true);
}
if (model == null)
{
model = EnclosingFinder <Procedure> .find(context.Element, true);
}
if (model == null)
{
model = EnclosingFinder <Structure> .find(context.Element, true);
}
if (model == null)
{
model = EnclosingFinder <Range> .find(context.Element, true);
}
if (model == null)
{
model = EnclosingFinder <DataDictionary.Types.Enum> .find(context.Element, true);
}
if (model == null)
{
model = EnclosingFinder <NameSpace> .find(context.Element, true);
}
if (model == null)
{
model = EnclosingFinder <Dictionary> .find(context.Element, true);
}
return(model);
}
/// <summary>
/// Indicates that a change event should be displayed
/// </summary>
/// <param name="modelElement"></param>
/// <param name="changeKind"></param>
/// <returns></returns>
protected virtual bool ShouldDisplayChange(IModelElement modelElement, Context.ChangeKind changeKind)
{
bool retVal = true;
// When end of cycle, only redisplay when the displayed element related to a variable
if (changeKind == Context.ChangeKind.EndOfCycle)
{
IVariable variable = EnclosingFinder <IVariable> .find(DisplayedModel, true);
retVal = (variable != null);
}
return(retVal);
}
/// <summary>
/// Indicates whether we need to keep this event during garbage collection
/// </summary>
/// <param name="evt"></param>
/// <returns></returns>
private bool KeepEvent(ModelEvent evt)
{
bool retVal = evt is Expect ||
evt is ModelInterpretationFailure ||
evt is SubStepActivated;
VariableUpdate update = evt as VariableUpdate;
if (update != null)
{
retVal = EnclosingFinder <NameSpace> .find(update.Action) == null;
}
return(retVal);
}
/// <summary>
/// Provides the set of rules which uses this variable
/// </summary>
/// <param name="node">the element to find in rules</param>
/// <returns>the list of rules which use the element provided</returns>
public static HashSet <RuleCondition> RulesUsingThisElement(IVariable node)
{
UsageVisitor visitor = new UsageVisitor(node);
EfsSystem efsSystem = EnclosingFinder <EfsSystem> .find(node);
if (efsSystem != null)
{
foreach (Dictionary dictionary in efsSystem.Dictionaries)
{
visitor.visit(dictionary);
}
}
return(visitor.Usages);
}
/// <summary>
/// Refactors an element which has a type
/// </summary>
/// <param name="element">The element that has been modified</param>
/// <param name="user">The user which references this type</param>
private static void RefactorTypedElement(ModelElement element, ITypedElement user)
{
if (user != null)
{
try
{
ModelElement enclosing = EnclosingFinder <NameSpace> .find(user, true);
Function function = user as Function;
if (function != null)
{
bool refactor = false;
Type current = function.ReturnType;
while (current != null && !refactor)
{
refactor = current == element;
current = EnclosingFinder <Type> .find(current);
}
if (refactor)
{
function.TypeName = function.ReturnType.ReferenceName(enclosing);
}
}
else
{
bool refactor = false;
Type current = user.Type;
while (current != null && !refactor)
{
refactor = current == element;
current = EnclosingFinder <Type> .find(current);
}
if (refactor)
{
user.TypeName = user.Type.ReferenceName(enclosing);
}
}
}
catch (Exception e)
{
((ModelElement)user).AddError("Cannot refactor this element, reason = " + e.Message);
}
}
}
public override void visit(BaseModelElement obj, bool visitSubNodes)
{
IExpressionable expressionnable = obj as IExpressionable;
if (expressionnable != null)
{
Function enclosingFunction = EnclosingFinder <Function> .find(obj, true);
if (enclosingFunction != null)
{
// The value of the function depends on this.
TheReferenceVisitor.UpdateReferences(enclosingFunction, expressionnable.Tree);
}
}
base.visit(obj, visitSubNodes);
}
/// <summary>
/// Adds a new element log attached to this model element
/// </summary>
/// <param name="log"></param>
public override void AddElementLog(ElementLog log)
{
if (!BeSilent)
{
Parameter enclosingParameter = EnclosingFinder <Parameter> .find(this);
if (enclosingParameter != null)
{
log.Log = "In " + FullName + ":" + log.Log;
enclosingParameter.AddElementLog(log);
}
else
{
base.AddElementLog(log);
EFSSystem.Context.HandleInfoMessageChangeEvent(this);
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="folder"></param>
/// <param name="buildSubNodes"></param>
public UsageTreeNode(IModelElement folder, bool buildSubNodes)
: base(null, buildSubNodes, folder.Name)
{
Usage = null;
FolderElement = folder;
ToolTipText = folder.FullName;
NameSpace nameSpace = EnclosingFinder <NameSpace> .find(folder, true);
if (nameSpace != null)
{
ChangeImageIndex(BaseTreeView.ModelImageIndex);
}
else
{
ChangeImageIndex(BaseTreeView.TestImageIndex);
}
}
/// <summary>
/// Selects the graphical element for the model provided
/// </summary>
/// <param name="model"></param>
public override void SelectModel(object model)
{
RuleCondition ruleCondition = EnclosingFinder <RuleCondition> .find(model as IModelElement, true);
if (ruleCondition != null)
{
base.SelectModel(ruleCondition);
}
else
{
State state = EnclosingFinder <State> .find(model as IModelElement, true);
if (state != null)
{
base.SelectModel(state);
}
}
}
/// <summary>
/// Adds a rule check message on the corresponding model element
/// </summary>
/// <param name="id"></param>
/// <param name="level"></param>
/// <param name="message"></param>
public void AddRuleCheckMessage(RuleChecksEnum id, ElementLog.LevelEnum level, string message)
{
bool enabled = true;
IRuleCheckDisabling ruleCheckDisabling = EnclosingFinder <IRuleCheckDisabling> .find(this, true);
while (enabled && ruleCheckDisabling != null)
{
if (ruleCheckDisabling.Disabling != null)
{
enabled = ruleCheckDisabling.Disabling.Enabled(id);
}
ruleCheckDisabling = EnclosingFinder <IRuleCheckDisabling> .find(ruleCheckDisabling as IEnclosed, false);
}
if (enabled)
{
AddElementLog(new ElementLog(level, id + ": " + message));
}
}
/// <summary>
/// Indicates that a change event should be displayed
/// </summary>
/// <param name="modelElement"></param>
/// <param name="changeKind"></param>
/// <returns></returns>
protected override bool ShouldDisplayChange(IModelElement modelElement, Context.ChangeKind changeKind)
{
bool retVal = modelElement == null;
if (!retVal)
{
if (changeKind != Context.ChangeKind.EndOfCycle)
{
Dictionary enclosing = EnclosingFinder <Dictionary> .find(modelElement, true);
retVal = (enclosing == Dictionary);
}
else
{
retVal = base.ShouldDisplayChange(modelElement, changeKind);
}
}
return(retVal);
}
/// <summary>
/// Called when the drop operation is performed on a node
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DragDropHandler(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent("WindowsForms10PersistentObject", false))
{
Point pt = ((TreeView)sender).PointToClient(new Point(e.X, e.Y));
BaseTreeNode destinationNode = (BaseTreeNode)((BaseTreeView)sender).GetNodeAt(pt);
object data = e.Data.GetData("WindowsForms10PersistentObject");
BaseTreeNode sourceNode = data as BaseTreeNode;
if (sourceNode != null && destinationNode != null)
{
if ((e.KeyState & Ctrl) != 0)
{
destinationNode.AcceptCopy(sourceNode);
}
else if ((e.KeyState & Alt) != 0)
{
destinationNode.AcceptMove(sourceNode);
}
else
{
destinationNode.AcceptDrop(sourceNode);
if (Refactor && Settings.Default.AllowRefactor)
{
NameSpace nameSpace = EnclosingFinder <NameSpace> .find(sourceNode.Model, true);
if (nameSpace != null)
{
// Only apply refactoring when dropping Model Element items
// This is useless for Requirements, and test related elements
RefactorAndRelocateOperation refactorAndRelocate =
new RefactorAndRelocateOperation(sourceNode.Model as ModelElement);
refactorAndRelocate.ExecuteUsingProgressDialog(GuiUtils.MdiWindow, "Refactoring", false);
}
}
}
}
}
}
/// <summary>
/// Provides the set of covered requirements by the model
/// </summary>
/// <param name="aDictionary">The model</param>
/// <param name="covered">Indicates if we need compute covered or non covered requirements</param>
/// <returns></returns>
public static HashSet <Paragraph> CoveredRequirements(Dictionary aDictionary, bool covered)
{
HashSet <Paragraph> retVal = new HashSet <Paragraph>();
ICollection <Paragraph> applicableParagraphs = aDictionary.ApplicableParagraphs;
Dictionary <Paragraph, List <ReqRef> > paragraphsReqRefDictionary = aDictionary.ParagraphsReqRefs;
foreach (Paragraph paragraph in applicableParagraphs)
{
bool implemented = paragraph.getImplementationStatus() ==
acceptor.SPEC_IMPLEMENTED_ENUM.Impl_Implemented;
if (implemented)
{
if (paragraphsReqRefDictionary.ContainsKey(paragraph))
{
List <ReqRef> implementations = paragraphsReqRefDictionary[paragraph];
for (int i = 0; i < implementations.Count; i++)
{
// the implementation may be also a ReqRef
if (implementations[i].Enclosing is ReqRelated)
{
ReqRelated reqRelated = implementations[i].Enclosing as ReqRelated;
// Do not consider tests
if (EnclosingFinder <Frame> .find(reqRelated) == null)
{
implemented = implemented && reqRelated.ImplementationCompleted;
}
}
}
}
}
if (implemented == covered)
{
retVal.Add(paragraph);
}
}
return(retVal);
}
/// <summary>
/// Refreshes the displayed model
/// </summary>
private void RefreshModel()
{
specBrowserRuleView.Nodes.Clear();
Paragraph paragraph = EnclosingFinder <Paragraph> .find(DisplayedModel, true);
if (paragraph == null)
{
ReqRef reqRef = DisplayedModel as ReqRef;
if (reqRef != null)
{
paragraph = reqRef.Paragraph;
}
}
if (paragraph != null)
{
foreach (ReqRef reqRef in paragraph.Implementations)
{
specBrowserRuleView.Nodes.Add(new ReqRefTreeNode(reqRef, true, false, reqRef.Model.Name));
}
functionalBlocksTreeView.SetRoot(paragraph);
}
specBrowserTreeView.RefreshModel(null);
}
/// <summary>
/// Allows to refresh the view, when the value of a model changed
/// </summary>
/// <param name="modelElement"></param>
/// <param name="changeKind"></param>
/// <returns>True if the view should be refreshed</returns>
public override bool HandleValueChange(IModelElement modelElement, Context.ChangeKind changeKind)
{
bool retVal = base.HandleValueChange(modelElement, changeKind);
if (retVal)
{
if (modelElement == null)
{
BoxArrowContainerPanel.RefreshControl();
}
else
{
TEnclosing enclosing = EnclosingFinder <TEnclosing> .find(modelElement, true);
while (enclosing != null)
{
if (enclosing == Model)
{
BoxArrowContainerPanel.RefreshControl();
enclosing = null;
}
else
{
enclosing = EnclosingFinder <TEnclosing> .find(enclosing as IEnclosed, false);
}
}
}
}
if (changeKind == Context.ChangeKind.EndOfCycle)
{
BoxArrowContainerPanel.Refresh();
}
return(retVal);
}
/// <summary>
/// Describes a specific Subset-076 specification issue
/// </summary>
/// <param name="paragraph"></param>
private void DescribeSpecIssue(Paragraph paragraph)
{
if (paragraph.SubParagraphs.Count > 0)
{
Report.AddSubParagraph(paragraph.Name);
Report.AddTable(new[] { "SubSequence", "Test case", "Step", "Comment" }, new[] { 60, 20, 10, 80 });
foreach (Paragraph subParagraph in paragraph.SubParagraphs)
{
DescribeSpecIssue(subParagraph);
}
Report.CloseSubParagraph();
}
else
{
Report.AddRow(paragraph.ExpressionText);
Report.SetLastRowColor(IssueColor(paragraph));
if (paragraph.Implementations.Count > 0)
{
foreach (ReqRef reqRef in paragraph.Implementations)
{
SubSequence subSequence = EnclosingFinder <SubSequence> .find(reqRef, true);
TestCase testCase = EnclosingFinder <TestCase> .find(reqRef, true);
Step step = EnclosingFinder <Step> .find(reqRef, true);
Report.AddRow(
subSequence != null ? subSequence.Name : "",
testCase != null ? testCase.getFeature().ToString(CultureInfo.InvariantCulture) : "",
step != null ? step.getTCS_Order().ToString(CultureInfo.InvariantCulture) : "",
reqRef.Comment);
}
}
}
}
/// <summary>
/// Provides the state machine from the context
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private static StateMachine GetStateMachine(Context.SelectionContext context)
{
StateMachine stateMachine;
State state = EnclosingFinder <State> .find(context.Element, true);
if (state != null && state.StateMachine.countStates() > 0)
{
stateMachine = state.StateMachine;
}
else
{
stateMachine = EnclosingFinder <StateMachine> .find(context.Element, true);
}
IVariable variable = context.Element as IVariable;
if (variable != null)
{
stateMachine = variable.Type as StateMachine;
}
return(stateMachine);
}
