/// <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> /// 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; }