/// <summary>
/// Ensures that all elements have a Guid
/// </summary>
/// <param name="obj"></param>
/// <param name="visitSubNodes"></param>
public override void visit(BaseModelElement obj, bool visitSubNodes)
{
ModelElement element = (ModelElement)obj;
if (UpdateGuid)
{
// Side effect : creates a new Guid if it is empty
// ReSharper disable once UnusedVariable
string guid = element.Guid;
}
// Make sure that the update information is consistent
if (!String.IsNullOrEmpty(element.Guid))
{
if (element.Updates != null)
{
element.SetUpdateInformation(element.Updates);
}
}
IExpressionable expressionable = obj as IExpressionable;
if (expressionable != null && ConvertObsoleteFile)
{
UpdateExpressionable(expressionable);
}
base.visit(obj, visitSubNodes);
}
/// <summary>
/// Allows to refresh the view, when the selected model changed
/// </summary>
/// <param name="context"></param>
/// <returns>true if refresh should be performed</returns>
public override bool HandleSelectionChange(Context.SelectionContext context)
{
bool retVal = base.HandleSelectionChange(context);
DisplayedModel = context.Element;
IEditable editable = DisplayedModel as IEditable;
if (editable != null)
{
SyntaxHighlight = editable.SyntaxHightlight;
AutoComplete = editable.SyntaxHightlight;
setChangeHandler(new EditableTextChangeHandler(editable));
}
else
{
IExpressionable expressionable = DisplayedModel as IExpressionable;
if (expressionable != null && !(expressionable is Function))
{
SyntaxHighlight = true;
AutoComplete = true;
setChangeHandler(new ExpressionableTextChangeHandler((ModelElement)expressionable));
}
else
{
setChangeHandler(null);
}
}
return(retVal);
}
/// <summary>
/// Executes the update and changes the corresponding Text field
/// </summary>
/// <returns>true if update was OK (either no change or successful change)</returns>
public void PerformUpdate(IExpressionable expressionable)
{
if (expressionable != null)
{
Text = expressionable.ExpressionText;
Delta = 0;
ModelElement.DontRaiseError(() =>
{
if (expressionable.Tree != null)
{
VisitInterpreterTreeNode(expressionable.Tree);
if (Text != expressionable.ExpressionText)
{
if (expressionable.checkValidExpression(Text))
{
expressionable.ExpressionText = Text;
}
else
{
throw new Exception("Cannot refactor expression " + expressionable.ExpressionText);
}
}
}
});
}
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value,
Type destinationType)
{
string retVal = "<unknown>";
IExpressionable expressionable = value as IExpressionable;
if (expressionable != null)
{
if (expressionable.ExpressionText != null)
{
retVal = expressionable.ExpressionText.Trim();
int index = retVal.IndexOf("\n");
if (index > 0)
{
retVal = retVal.Substring(0, index) + "...";
}
}
else
{
retVal = "";
}
}
return(retVal);
}
/// <summary>
/// Executes the update and changes the corresponding Text field
/// </summary>
/// <returns>true if update was OK (either no change or successful change)</returns>
public void PerformUpdate(IExpressionable expressionable)
{
if (expressionable != null)
{
Text = expressionable.ExpressionText;
Delta = 0;
ModelElement.DontRaiseError(() =>
{
if (expressionable.Tree != null)
{
VisitInterpreterTreeNode(expressionable.Tree);
if (Text != expressionable.ExpressionText)
{
if (expressionable.checkValidExpression(Text))
{
expressionable.ExpressionText = Text;
}
else
{
throw new Exception("Cannot refactor expression " + expressionable.ExpressionText);
}
}
}
});
}
}
/// <summary>
/// Refactors all IExpressionables
/// </summary>
/// <param name="obj"></param>
/// <param name="visitSubNodes"></param>
public override void visit(BaseModelElement obj, bool visitSubNodes)
{
IExpressionable expressionable = obj as IExpressionable;
if (expressionable != null)
{
RefactorIExpressionable(null, expressionable);
}
base.visit(obj, visitSubNodes);
}
/// <summary>
/// The way text is retrieved from the instance
/// </summary>
/// <returns></returns>
public override string GetText()
{
string retVal = "";
IExpressionable expressionable = Instance as IExpressionable;
if (expressionable != null)
{
retVal = expressionable.ExpressionText;
}
return(retVal);
}
/// <summary>
/// Updates the expressionable, according to the grammar changes
/// </summary>
/// <param name="expressionable"></param>
private void UpdateExpressionable(IExpressionable expressionable)
{
string expression = expressionable.ExpressionText;
expression = Replace(expression, "USING", "USING X IN");
expression = Replace(expression, "THERE_IS_IN", "THERE_IS X IN");
expression = Replace(expression, "LAST_IN", "LAST X IN");
expression = Replace(expression, "FIRST_IN", "FIRST X IN");
expression = Replace(expression, "FORALL_IN", "FORALL X IN");
expression = Replace(expression, "COUNT", "COUNT X IN");
expressionable.ExpressionText = expression;
}
public override void visit(BaseModelElement obj, bool visitSubNodes)
{
IExpressionable expressionable = obj as IExpressionable;
if (expressionable != null)
{
// In case of rebuild, cleans the previously constructed tree
if (Options.Rebuild)
{
expressionable.CleanCompilation();
}
// Ensures that the expressionable is compiled
expressionable.Compile();
Structure structure = expressionable as Structure;
if (structure != null)
{
if (structure != structure.UnifiedStructure)
{
visit(structure.UnifiedStructure, visitSubNodes);
}
}
StateMachine stateMachine = expressionable as StateMachine;
if (stateMachine != null)
{
if (stateMachine != stateMachine.UnifiedStateMachine)
{
visit(stateMachine.UnifiedStateMachine, visitSubNodes);
}
}
}
ITypedElement typedElement = obj as ITypedElement;
if (typedElement != null)
{
// Ensures that the type of the corresponding element is cached
Type type = typedElement.Type;
}
Function function = obj as Function;
if (function != null)
{
Type returnType = function.ReturnType;
}
base.visit(obj, visitSubNodes);
}
/// <summary>
/// The way text is set back in the instance
/// </summary>
/// <returns></returns>
public override void SetText(string text)
{
text = RemoveUselessCharacters(text);
IExpressionable expressionable = Instance as IExpressionable;
if (expressionable != null)
{
string originalText = RemoveUselessCharacters(expressionable.ExpressionText);
if (originalText != text)
{
expressionable.ExpressionText = text;
}
}
}
public override void visit(BaseModelElement obj, bool visitSubNodes)
{
IExpressionable expressionable = obj as IExpressionable;
if (expressionable != null)
{
// Perform search and replace on ExpressionText
if (obj.ExpressionText.IndexOf(SearchString) >= 0)
{
obj.ExpressionText = obj.ExpressionText.Replace(SearchString, ReplaceString);
}
}
base.visit(obj, visitSubNodes);
}
/// <summary>
/// Refactors an element which can hold an expression
/// </summary>
/// <param name="element">The element that has been modified, and for which refactoring is done</param>
/// <param name="user">The user, which can hold an expression</param>
private static void RefactorIExpressionable(ModelElement element, IExpressionable user)
{
if (user != null)
{
try
{
RefactorTree refactorer = new RefactorTree(element, user as ModelElement);
refactorer.PerformUpdate(user);
}
catch (Exception e)
{
((ModelElement)user).AddWarning("Cannot refactor this element, reason = " + e.Message);
}
}
}
/// <summary>
/// Refactors an element which can hold an expression
/// </summary>
/// <param name="element">The element that has been modified, and for which refactoring is done</param>
/// <param name="user">The user, which can hold an expression</param>
public static void RefactorIExpressionable(ModelElement element, IExpressionable user)
{
if (user != null)
{
try
{
RefactorTree refactorer = new RefactorTree(element, user as ModelElement);
refactorer.PerformUpdate(user);
}
catch (Exception e)
{
((ModelElement)user).AddWarning("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);
}
public override void visit(BaseModelElement obj, bool visitSubNodes)
{
IExpressionable expressionable = obj as IExpressionable;
if (expressionable != null)
{
try
{
RelocateTree refactorer = new RelocateTree(BaseLocation);
refactorer.PerformUpdate(expressionable);
}
catch (Exception e)
{
obj.AddWarning("Cannot refactor this element, reason = " + e.Message);
}
}
base.visit(obj, visitSubNodes);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (provider != null)
{
IWindowsFormsEditorService svc =
provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (svc != null)
{
IExpressionable expressionable = value as IExpressionable;
if (expressionable != null)
{
Window form = new Window();
ExpressionableTextChangeHandler handler =
new ExpressionableTextChangeHandler(expressionable as ModelElement);
form.setChangeHandler(handler);
GuiUtils.MdiWindow.AddChildWindow(form, DockAreas.Float);
}
}
}
return(value);
}
/// <summary>
/// Provides the expression
/// </summary>
/// <param name="element"></param>
public void Expression(ModelElement element)
{
IExpressionable expressionable = element as IExpressionable;
if (expressionable != null)
{
if (expressionable.Tree != null)
{
expressionable.Tree.GetExplain(this);
}
else
{
if (string.IsNullOrEmpty(expressionable.ExpressionText))
{
Write("<Undefined expression or statement>");
}
else
{
Write(expressionable.ExpressionText);
}
}
}
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
object retVal = null;
BaseTreeNode.BaseEditor editor = context.Instance as BaseTreeNode.BaseEditor;
string text = value as string;
if (editor != null && text != null)
{
IExpressionable expressionable = editor.Model as IExpressionable;
if (expressionable != null)
{
expressionable.ExpressionText = text;
retVal = expressionable;
}
}
if (retVal == null)
{
retVal = base.ConvertFrom(context, culture, value);
}
return(retVal);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="timeLine"></param>
/// <param name="instance"></param>
public TimeLineExpressionableTextChangeHandler(StaticTimeLineControl timeLine, IExpressionable instance)
: base(instance as ModelElement)
{
TimeLine = timeLine;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="timeLine"></param>
/// <param name="instance"></param>
public TimeLineExpressionableTextChangeHandler(StaticTimeLineControl timeLine, IExpressionable instance)
: base(instance as ModelElement)
{
TimeLine = timeLine;
}
