/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
if (!string.IsNullOrEmpty(getCondition()))
{
explanation.Write("IF ");
if (ConditionTree != null)
{
ConditionTree.GetExplain(explanation);
}
else
{
explanation.Write(getCondition());
}
explanation.WriteLine(" THEN");
explanation.Indent(2, () => explanation.Expression(this));
explanation.WriteLine("END IF");
}
else
{
explanation.Expression(this);
explanation.WriteLine();
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("FOLDER ");
explanation.WriteLine(Name);
if (explainSubElements)
{
explanation.Indent(2, () =>
{
foreach (Folder folder in Folders)
{
folder.GetExplain(explanation, explainSubElements);
}
});
}
explanation.Indent(2, () =>
{
foreach (Translation translation in Translations)
{
translation.GetExplain(explanation, explainSubElements);
}
});
explanation.Write("END FOLDER ");
explanation.WriteLine(Name);
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
if (!IsAbstract)
{
explanation.Write("STRUCTURE ");
}
else
{
explanation.Write("INTERFACE ");
}
explanation.WriteLine(Name);
explanation.Indent(2, () =>
{
foreach (Structure structure in Interfaces)
{
if (structure != null)
{
explanation.Write("IMPLEMENTS ");
explanation.WriteLine(structure.Name);
}
}
foreach (StructureElement element in Elements)
{
explanation.Write(element, explainSubElements);
}
if (!IsAbstract)
{
foreach (Procedure procedure in Procedures)
{
explanation.Write(procedure, explainSubElements);
}
foreach (StateMachine stateMachine in StateMachines)
{
explanation.Write(stateMachine, explainSubElements);
}
foreach (Rule rule in Rules)
{
explanation.Write(rule, explainSubElements);
}
}
});
if (!IsAbstract)
{
explanation.WriteLine("END STRUCTURE");
}
else
{
explanation.WriteLine("END INTERFACE");
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
int indent = 0;
if (PreConditions.Count > 0)
{
indent = 2;
explanation.Write("IF ");
if (PreConditions.Count > 1)
{
// Prepare the space for the following ANDs
explanation.Write(" ");
}
bool first = true;
foreach (PreCondition preCondition in PreConditions)
{
if (!first)
{
explanation.WriteLine();
explanation.Write(" AND ");
}
preCondition.GetExplain(explanation, explainSubElements);
first = false;
}
explanation.WriteLine();
explanation.WriteLine("THEN");
}
else
{
explanation.WriteLine();
}
explanation.Indent(indent, () =>
{
if (Name.CompareTo(EnclosingRule.Name) != 0)
{
explanation.Comment(Name);
}
foreach (Action action in Actions)
{
explanation.Write();
action.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
if (explainSubElements)
{
foreach (Rule subRule in SubRules)
{
subRule.GetExplain(explanation, explainSubElements);
}
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.WriteLine("SOURCE TEXT ");
explanation.WriteLine(Name);
explanation.Indent(2, () =>
{
foreach (SourceTextComment comment in Comments)
{
explanation.Write("COMMENT");
explanation.WriteLine(comment.Name);
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Write(Name);
if (!String.IsNullOrEmpty(getValue()))
{
explanation.WriteLine(" : " + getValue());
}
else
{
explanation.WriteLine();
}
}
protected void InsertElement(ITypedElement element, TextualExplanation text)
{
text.Write(element.Name);
text.Write(" => ");
Structure structure = element.Type as Structure;
if (structure != null)
{
text.WriteLine(StripUseless(structure.FullName, WritingContext()) + "{");
text.Indent(4, () =>
{
bool first = true;
foreach (StructureElement subElement in structure.Elements)
{
if (!first)
{
text.WriteLine(",");
}
InsertElement(subElement, text);
first = false;
}
});
text.WriteLine();
text.Write("}");
}
else
{
IValue value = null;
if (string.IsNullOrEmpty(element.Default))
{
// No default value for element, get the one of the type
if (element.Type != null && element.Type.DefaultValue != null)
{
value = element.Type.DefaultValue;
}
}
else
{
if (element.Type != null)
{
value = element.Type.getValue(element.Default);
}
}
if (value != null)
{
text.Write(StripUseless(value.FullName, WritingContext()));
}
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements = true)
{
explanation.Write(Structure);
explanation.WriteLine();
explanation.Write("{");
explanation.Indent(2, () => explanation.ExplainList(Associations, explainSubElements, ", ", element =>
{
explanation.WriteLine();
explanation.Write(element.Key);
explanation.Write(" => ");
explanation.Write(element.Value);
}));
explanation.WriteLine();
explanation.Write("}");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("STATE ");
explanation.WriteLine(Name);
if (explainSubElements)
{
foreach (Rule rule in StateMachine.Rules)
{
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
rule.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
}
}
private void Editor_KeyPress(object sender, KeyPressEventArgs e)
{
try
{
if (AutoComplete)
{
switch (e.KeyChar)
{
case '.':
EditionTextBox.SelectedText = e.KeyChar.ToString(CultureInfo.InvariantCulture);
e.Handled = true;
DisplayComboBox();
break;
case '{':
Structure structure = GetInstance(EditionTextBox.SelectionStart - 1) as Structure;
if (structure != null)
{
TextualExplanation text = new TextualExplanation();
text.WriteLine("{");
CreateDefaultStructureValue(text, structure, false);
EditionTextBox.SelectedText = text.Text;
EditionTextBox.ProcessAllLines(true);
e.Handled = true;
}
break;
case '(':
ICallable callable = GetInstance(EditionTextBox.SelectionStart - 1) as ICallable;
if (callable != null)
{
TextualExplanation text = new TextualExplanation();
CreateCallableParameters(text, callable);
EditionTextBox.SelectedText = text.Text;
EditionTextBox.ProcessAllLines(true);
e.Handled = true;
}
break;
case '>':
case '-':
char prev = EditionTextBox.Text[EditionTextBox.SelectionStart - 1];
if ((prev == '<' && e.KeyChar == '-') || (prev == '=' && e.KeyChar == '>'))
{
ITypedElement typedElement =
GetInstance(EditionTextBox.SelectionStart - 2) as ITypedElement;
if (typedElement != null)
{
EditionTextBox.SelectedText = e.KeyChar + " " + typedElement.Type.FullName;
e.Handled = true;
}
}
break;
}
}
}
catch (Exception)
{
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements = true)
{
explanation.Write(Called);
explanation.Write("(");
explanation.ExplainList(ActualParameters, explainSubElements, ", ",
element => element.GetExplain(explanation));
if (NamedActualParameters.Count > 0)
{
explanation.Indent(2, () =>
{
if (ActualParameters.Count > 0)
{
explanation.Write(", ");
}
explanation.ExplainList(NamedActualParameters, explainSubElements, ", ", pair =>
{
if (AllParameters.Count > 1)
{
explanation.WriteLine();
}
explanation.Write(pair.Key);
explanation.Write(" => ");
explanation.Write(pair.Value);
});
});
}
explanation.Write(")");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
base.GetExplain(explanation, explainSubElements);
explanation.Write("COLLECTION ");
explanation.Write(Name);
explanation.Write(" OF ");
explanation.WriteLine(getTypeName());
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("TRANSLATION ");
explanation.WriteLine(Name);
if (SourceTexts.Count > 0)
{
foreach (SourceText text in SourceTexts)
{
text.GetExplain(explanation, explainSubElements);
}
}
foreach (SubStep subStep in SubSteps)
{
subStep.GetExplain(explanation, explainSubElements);
}
explanation.WriteLine("END TRANSLATION ");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
if (PreConditions.Count > 0)
{
explanation.Write("IF ");
if (PreConditions.Count > 1)
{
// Prepare the space for the following ANDs
explanation.Write(" ");
}
bool first = true;
foreach (PreCondition preCondition in PreConditions)
{
if (!first)
{
explanation.WriteLine();
explanation.Write(" AND ");
}
preCondition.GetExplain(explanation, explainSubElements);
first = false;
}
explanation.WriteLine(" THEN");
explanation.Indent(2, () =>
{
explanation.Header(this);
explanation.Expression(this);
});
}
else
{
explanation.WriteLine();
explanation.Indent(2, () =>
{
explanation.Header(this);
explanation.Expression(this);
});
}
}
protected void CreateDefaultStructureValue(TextualExplanation text, Structure structure,
bool displayStructureName = true)
{
if (displayStructureName)
{
text.WriteLine(StripUseless(structure.FullName, WritingContext()) + "{");
}
bool first = true;
foreach (StructureElement element in structure.Elements)
{
if (!first)
{
text.WriteLine(",");
}
InsertElement(element, text);
first = false;
}
text.WriteLine();
text.Write("}");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Indent(2, () =>
{
foreach (Step step in Steps)
{
step.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
bool first = true;
bool condition = false;
foreach (RuleCondition ruleCondition in RuleConditions)
{
if (!first)
{
explanation.WriteLine("ELSE");
}
ruleCondition.GetExplain(explanation, explainSubElements);
first = false;
condition = condition || ruleCondition.PreConditions.Count > 0;
}
if (condition)
{
explanation.WriteLine("END IF");
}
}
protected void CreateCallableParameters(TextualExplanation text, ICallable callable)
{
if (callable.FormalParameters.Count > 0)
{
if (callable.FormalParameters.Count == 1)
{
Parameter formalParameter = callable.FormalParameters[0] as Parameter;
if (formalParameter != null)
{
text.Write("( " + formalParameter.Name + " => " + formalParameter.Type.Default + " )");
}
}
else
{
text.WriteLine("(");
text.Indent(4, () =>
{
bool first = true;
foreach (Parameter parameter in callable.FormalParameters)
{
if (!first)
{
text.WriteLine(",");
}
text.Write(parameter.Name + " => " + parameter.Type.Default);
first = false;
}
});
text.WriteLine();
text.Write(")");
}
}
else
{
text.Write("()");
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
base.GetExplain(explanation, explainSubElements);
explanation.Write("ENUMERATION ");
explanation.WriteLine(Name);
explanation.Indent(2, () =>
{
foreach (EnumValue enumValue in Values)
{
explanation.Write(enumValue, explainSubElements);
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(Name);
explanation.Indent(2, () =>
{
foreach (Action action in Actions)
{
action.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
});
explanation.WriteLine("IMPLIES");
explanation.Indent(2, () =>
{
foreach (Expectation expectation in Expectations)
{
expectation.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
string typeName = TypeName;
if (Type != null)
{
typeName = Type.FullName;
}
explanation.Write("FIELD ");
explanation.Write(Name);
explanation.Write(" : ");
explanation.WriteLine(typeName);
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
base.GetExplain(explanation, explainSubElements);
explanation.Write("STATE MACHINE ");
explanation.WriteLine(Name);
explanation.Indent(2, () =>
{
foreach (State state in States)
{
explanation.Write(state, false);
}
foreach (Rule rule in Rules)
{
explanation.Write(rule, explainSubElements);
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
base.GetExplain(explanation, explainSubElements);
explanation.Write("RANGE ");
explanation.Write(Name);
explanation.Write(" FROM ");
explanation.Write(MinValue);
explanation.Write(" TO ");
explanation.WriteLine(MaxValue);
explanation.Indent(2, () =>
{
foreach (EnumValue enumValue in SpecialValues)
{
explanation.Write(enumValue, explainSubElements);
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Write("PROCEDURE ");
explanation.Write(Name);
if (FormalParameters.Count > 0)
{
bool first = true;
explanation.Write("(");
if (FormalParameters.Count > 1)
{
explanation.WriteLine();
}
explanation.Indent(4, () =>
{
foreach (Parameter parameter in FormalParameters)
{
if (!first)
{
explanation.WriteLine(",");
}
explanation.Write(parameter.Name);
explanation.Write(" : ");
explanation.Write(parameter.TypeName);
first = false;
}
});
explanation.WriteLine(")");
}
else
{
explanation.WriteLine("()");
}
explanation.Indent(2, () =>
{
foreach (Rule rule in Rules)
{
rule.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
});
explanation.WriteLine("END PROCEDURE ");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
if (string.IsNullOrEmpty(Comment))
{
if (Type != null)
{
explanation.Comment(Type);
}
}
else
{
explanation.Comment(this);
}
explanation.Write(Name);
explanation.Write(" : ");
explanation.Write(TypeName);
if (Value != null)
{
explanation.Write(" = ");
explanation.Write(Value.LiteralName);
}
explanation.WriteLine();
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("STATE ");
explanation.WriteLine(Name);
if (explainSubElements)
{
foreach (Rule rule in StateMachine.Rules)
{
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
rule.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("FOLDER ");
explanation.WriteLine(Name);
if (explainSubElements)
{
explanation.Indent(2, () =>
{
foreach (Folder folder in Folders)
{
folder.GetExplain(explanation, explainSubElements);
}
});
}
explanation.Indent(2, () =>
{
foreach (Translation translation in Translations)
{
translation.GetExplain(explanation, explainSubElements);
}
});
explanation.Write("END FOLDER ");
explanation.WriteLine(Name);
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
base.GetExplain(explanation, explainSubElements);
explanation.Write("RANGE ");
explanation.Write(Name);
explanation.Write(" FROM ");
explanation.Write(MinValue);
explanation.Write(" TO ");
explanation.WriteLine(MaxValue);
explanation.Indent(2, () =>
{
foreach (EnumValue enumValue in SpecialValues)
{
enumValue.GetExplain(explanation, explainSubElements);
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.WriteLine(Changes.ToString());
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
if (!IsAbstract)
{
explanation.Write("STRUCTURE ");
}
else
{
explanation.Write("INTERFACE ");
}
explanation.WriteLine(Name);
explanation.Indent(2, () =>
{
foreach (Structure structure in Interfaces)
{
if (structure != null)
{
explanation.Write("IMPLEMENTS ");
explanation.WriteLine(structure.Name);
}
}
foreach (StructureElement element in Elements)
{
element.GetExplain(explanation, explainSubElements);
}
if (!IsAbstract)
{
foreach (Procedure procedure in Procedures)
{
procedure.GetExplain(explanation, explainSubElements);
}
foreach (StateMachine stateMachine in StateMachines)
{
stateMachine.GetExplain(explanation, explainSubElements);
}
foreach (Rule rule in Rules)
{
rule.GetExplain(explanation, explainSubElements);
}
}
});
if (!IsAbstract)
{
explanation.WriteLine("END STRUCTURE");
}
else
{
explanation.WriteLine("END INTERFACE");
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.WriteLine(LiteralName);
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
int indent = 0;
if (PreConditions.Count > 0)
{
indent = 2;
explanation.Write("IF ");
if (PreConditions.Count > 1)
{
// Prepare the space for the following ANDs
explanation.Write(" ");
}
bool first = true;
foreach (PreCondition preCondition in PreConditions)
{
if (!first)
{
explanation.WriteLine();
explanation.Write(" AND ");
}
preCondition.GetExplain(explanation, explainSubElements);
first = false;
}
explanation.WriteLine();
explanation.WriteLine("THEN");
}
else
{
explanation.WriteLine();
}
explanation.Indent(indent, () =>
{
if (Name.CompareTo(EnclosingRule.Name) != 0)
{
explanation.Comment(Name);
}
foreach (Action action in Actions)
{
explanation.Write();
action.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
if (explainSubElements)
{
foreach (Rule subRule in SubRules)
{
subRule.GetExplain(explanation, explainSubElements);
}
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Write("NAMESPACE ");
explanation.WriteLine(Name);
}
protected void InsertElement(ITypedElement element, TextualExplanation text)
{
text.Write(element.Name);
text.Write(" => ");
Structure structure = element.Type as Structure;
if (structure != null)
{
text.WriteLine(StripUseless(structure.FullName, WritingContext()) + "{");
text.Indent(4, () =>
{
bool first = true;
foreach (StructureElement subElement in structure.Elements)
{
if (!first)
{
text.WriteLine(",");
}
InsertElement(subElement, text);
first = false;
}
});
text.WriteLine();
text.Write("}");
}
else
{
IValue value = null;
if (string.IsNullOrEmpty(element.Default))
{
// No default value for element, get the one of the type
if (element.Type != null && element.Type.DefaultValue != null)
{
value = element.Type.DefaultValue;
}
}
else
{
if (element.Type != null)
{
value = element.Type.getValue(element.Default);
}
}
if (value != null)
{
text.Write(StripUseless(value.FullName, WritingContext()));
}
}
}
private void Editor_KeyPress(object sender, KeyPressEventArgs e)
{
try
{
if (AutoComplete)
{
switch (e.KeyChar)
{
case '.':
EditionTextBox.SelectedText = e.KeyChar.ToString(CultureInfo.InvariantCulture);
e.Handled = true;
DisplayComboBox();
break;
case '{':
Structure structure = GetInstance(EditionTextBox.SelectionStart-1) as Structure;
if (structure != null)
{
TextualExplanation text = new TextualExplanation();
text.WriteLine("{");
CreateDefaultStructureValue(text, structure, false);
EditionTextBox.SelectedText = text.Text;
EditionTextBox.ProcessAllLines(true);
e.Handled = true;
}
break;
case '(':
ICallable callable = GetInstance(EditionTextBox.SelectionStart-1) as ICallable;
if (callable != null)
{
TextualExplanation text = new TextualExplanation();
CreateCallableParameters(text, callable);
EditionTextBox.SelectedText = text.Text;
EditionTextBox.ProcessAllLines(true);
e.Handled = true;
}
break;
case '>':
case '-':
char prev = EditionTextBox.Text[EditionTextBox.SelectionStart - 1];
if ((prev == '<' && e.KeyChar == '-') || (prev == '=' && e.KeyChar == '>'))
{
ITypedElement typedElement =
GetInstance(EditionTextBox.SelectionStart - 2) as ITypedElement;
if (typedElement != null)
{
EditionTextBox.SelectedText = e.KeyChar + " " + typedElement.Type.FullName;
e.Handled = true;
}
}
break;
}
}
}
catch (Exception)
{
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
base.GetExplain(explanation, explainSubElements);
explanation.Write("ENUMERATION ");
explanation.WriteLine(Name);
explanation.Indent(2, () =>
{
foreach (EnumValue enumValue in Values)
{
explanation.Write(enumValue, explainSubElements);
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
string typeName = TypeName;
if (Type != null)
{
typeName = Type.FullName;
}
explanation.Write("FIELD ");
explanation.Write(Name);
explanation.Write(" : ");
explanation.WriteLine(typeName);
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("TRANSLATION ");
explanation.WriteLine(Name);
if (SourceTexts.Count > 0)
{
foreach (SourceText text in SourceTexts)
{
text.GetExplain(explanation, explainSubElements);
}
}
foreach (SubStep subStep in SubSteps)
{
subStep.GetExplain(explanation, explainSubElements);
}
explanation.WriteLine("END TRANSLATION ");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("REQUIREMENT SET ");
explanation.WriteLine(Name);
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Write("NAMESPACE ");
explanation.WriteLine(Name);
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
bool first = true;
bool condition = false;
foreach (RuleCondition ruleCondition in RuleConditions)
{
if (!first)
{
explanation.WriteLine("ELSE");
}
ruleCondition.GetExplain(explanation, explainSubElements);
first = false;
condition = condition || ruleCondition.PreConditions.Count > 0;
}
if (condition)
{
explanation.WriteLine("END IF");
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("MODEL EVENT ");
explanation.WriteLine(ToString());
}
protected void CreateCallableParameters(TextualExplanation text, ICallable callable)
{
if (callable.FormalParameters.Count > 0)
{
if (callable.FormalParameters.Count == 1)
{
Parameter formalParameter = callable.FormalParameters[0] as Parameter;
if(formalParameter != null)
{
text.Write("( " + formalParameter.Name + " => " + formalParameter.Type.Default + " )");
}
}
else
{
text.WriteLine("(");
text.Indent(4, () =>
{
bool first = true;
foreach (Parameter parameter in callable.FormalParameters)
{
if (!first)
{
text.WriteLine(",");
}
text.Write(parameter.Name + " => " + parameter.Type.Default);
first = false;
}
});
text.WriteLine();
text.Write(")");
}
}
else
{
text.Write("()");
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Write("PROCEDURE ");
explanation.Write(Name);
if (FormalParameters.Count > 0)
{
bool first = true;
explanation.Write("(");
if (FormalParameters.Count > 1)
{
explanation.WriteLine();
}
explanation.Indent(4, () =>
{
foreach (Parameter parameter in FormalParameters)
{
if (!first)
{
explanation.WriteLine(",");
}
explanation.Write(parameter.Name);
explanation.Write(" : ");
explanation.Write(parameter.TypeName);
first = false;
}
});
explanation.WriteLine(")");
}
else
{
explanation.WriteLine("()");
}
explanation.Indent(2, () =>
{
foreach (Rule rule in Rules)
{
rule.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
});
explanation.WriteLine("END PROCEDURE ");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("REQUIREMENT SET ");
explanation.WriteLine(Name);
}
protected void CreateDefaultStructureValue(TextualExplanation text, Structure structure,
bool displayStructureName = true)
{
if (displayStructureName)
{
text.WriteLine(StripUseless(structure.FullName, WritingContext()) + "{");
}
bool first = true;
foreach (StructureElement element in structure.Elements)
{
if (!first)
{
text.WriteLine(",");
}
InsertElement(element, text);
first = false;
}
text.WriteLine();
text.Write("}");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
if (string.IsNullOrEmpty(Comment))
{
if (Type != null)
{
explanation.Comment(Type);
}
}
else
{
explanation.Comment(this);
}
explanation.Write(Name);
explanation.Write(" : ");
explanation.Write(TypeName);
if (Value != null)
{
explanation.Write(" = ");
explanation.Write(Value.LiteralName);
}
explanation.WriteLine();
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(Name);
explanation.Indent(2, () =>
{
foreach (Action action in Actions)
{
action.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
});
explanation.WriteLine("IMPLIES");
explanation.Indent(2, () =>
{
foreach (Expectation expectation in Expectations)
{
expectation.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Write("FUNCTION ");
explanation.Write(Name);
explanation.Write(" (");
if (FormalParameters.Count > 0)
{
explanation.Indent(2, () =>
{
bool first = true;
foreach (Parameter parameter in FormalParameters)
{
if (first)
{
explanation.WriteLine();
first = false;
}
else
{
explanation.WriteLine(",");
}
parameter.GetExplain(explanation, true);
}
});
}
explanation.WriteLine(")");
explanation.Write("RETURNS ");
explanation.WriteLine(TypeName);
{
bool first = true;
foreach (Case cas in Cases)
{
if (!first)
{
explanation.Write("ELSE ");
}
cas.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
first = false;
}
}
explanation.Write("END FUNCTION");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
if (!string.IsNullOrEmpty(getCondition()))
{
explanation.Write("IF ");
if (ConditionTree != null)
{
ConditionTree.GetExplain(explanation);
}
else
{
explanation.Write(getCondition());
}
explanation.WriteLine(" THEN");
explanation.Indent(2, () => explanation.Expression(this));
explanation.WriteLine("END IF");
}
else
{
explanation.Expression(this);
explanation.WriteLine();
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.WriteLine("SOURCE TEXT ");
explanation.WriteLine(Name);
explanation.Indent(2, () =>
{
foreach (SourceTextComment comment in this.Comments)
{
explanation.Write("COMMENT");
explanation.WriteLine(comment.Name);
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
base.GetExplain(explanation, explainSubElements);
explanation.Write("STATE MACHINE ");
explanation.WriteLine(Name);
explanation.Indent(2, () =>
{
foreach (State state in States)
{
state.GetExplain(explanation, false);
}
foreach (Rule rule in Rules)
{
rule.GetExplain(explanation, explainSubElements);
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.WriteLine(Changes.ToString());
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Write(Name);
if (!String.IsNullOrEmpty(getValue()))
{
explanation.WriteLine(" : " + getValue());
}
else
{
explanation.WriteLine();
}
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Write("MODEL EVENT ");
explanation.WriteLine(ToString());
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
base.GetExplain(explanation, explainSubElements);
explanation.Write("COLLECTION ");
explanation.Write(Name);
explanation.Write(" OF ");
explanation.WriteLine(getTypeName());
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements = true)
{
Structure.GetExplain(explanation);
explanation.Write("{");
explanation.Indent(2, () => explanation.ExplainList(Associations, explainSubElements, ", ", element =>
{
explanation.WriteLine();
element.Key.GetExplain(explanation);
explanation.Write(" => ");
element.Value.GetExplain(explanation);
}));
explanation.WriteLine();
explanation.Write("}");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public override void GetExplain(TextualExplanation explanation, bool explainSubElements = true)
{
Called.GetExplain(explanation);
explanation.Write("(");
explanation.ExplainList(ActualParameters, explainSubElements, ", ",
element => element.GetExplain(explanation));
if (NamedActualParameters.Count > 0)
{
explanation.Indent(2, () =>
{
if (ActualParameters.Count > 0)
{
explanation.Write(", ");
}
explanation.ExplainList(NamedActualParameters, explainSubElements, ", ", pair =>
{
if (AllParameters.Count > 1)
{
explanation.WriteLine();
}
pair.Key.GetExplain(explanation);
explanation.Write(" => ");
pair.Value.GetExplain(explanation);
});
});
}
explanation.Write(")");
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
explanation.Comment(this);
explanation.Indent(2, () =>
{
foreach (Step step in Steps)
{
step.GetExplain(explanation, explainSubElements);
explanation.WriteLine();
}
});
}
/// <summary>
/// Builds the explanation of the element
/// </summary>
/// <param name="explanation"></param>
/// <param name="explainSubElements">Precises if we need to explain the sub elements (if any)</param>
public virtual void GetExplain(TextualExplanation explanation, bool explainSubElements)
{
if (PreConditions.Count > 0)
{
explanation.Write("IF ");
if (PreConditions.Count > 1)
{
// Prepare the space for the following ANDs
explanation.Write(" ");
}
bool first = true;
foreach (PreCondition preCondition in PreConditions)
{
if (!first)
{
explanation.WriteLine();
explanation.Write(" AND ");
}
preCondition.GetExplain(explanation, explainSubElements);
first = false;
}
explanation.WriteLine(" THEN");
explanation.Indent(2, () =>
{
explanation.Header(this);
explanation.Expression(this);
});
}
else
{
explanation.WriteLine();
explanation.Indent(2, () =>
{
explanation.Header(this);
explanation.Expression(this);
});
}
}