void project_ParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (testProject != null) { testProject.NotifyParseInformationChanged(e.OldUnresolvedFile, e.NewUnresolvedFile); } }
async void UpdateTick(ParseInformationEventArgs e) { bool isActive = ctl.IsVisible && !SD.ParserService.LoadSolutionProjectsThread.IsRunning; timer.IsEnabled = isActive; if (!isActive) { return; } LoggingService.Debug("DefinitionViewPad.Update"); ResolveResult res = await ResolveAtCaretAsync(e); if (res == null) { return; } var pos = res.GetDefinitionRegion(); if (pos.IsEmpty) { return; // TODO : try to decompile? } OpenFile(pos); }
public void ParserServiceParseInformationUpdated(object sender, ParseInformationEventArgs e) { lock (pending) { pending.Add(e); } WorkbenchSingleton.SafeThreadAsyncCall(UpdateThread); }
public void ParserServiceParseInformationUpdated(object sender, ParseInformationEventArgs e) { lock (pending) { pending.Add(new ICompilationUnit[] { e.ParseInformation.MostRecentCompilationUnit as ICompilationUnit, e.CompilationUnit }); } WorkbenchSingleton.SafeThreadAsyncCall(UpdateThread); }
Task <ResolveResult> ResolveAtCaretAsync(ParseInformationEventArgs e) { IWorkbenchWindow window = SD.Workbench.ActiveWorkbenchWindow; if (window == null) { return(Task.FromResult <ResolveResult>(null)); } IViewContent viewContent = window.ActiveViewContent; if (viewContent == null) { return(Task.FromResult <ResolveResult>(null)); } ITextEditor editor = viewContent.GetService <ITextEditor>(); if (editor == null) { return(Task.FromResult <ResolveResult>(null)); } // e might be null when this is a manually triggered update // don't resolve when an unrelated file was changed if (e != null && editor.FileName != e.FileName) { return(Task.FromResult <ResolveResult>(null)); } return(SD.ParserService.ResolveAsync(editor.FileName, editor.Caret.Location, editor.Document)); }
void ParseInformationUpdated(object source, ParseInformationEventArgs e) { lock (pending) { ICompilationUnit[] units = new ICompilationUnit[] { e.OldCompilationUnit, e.NewCompilationUnit }; pending.Add(units); } WorkbenchSingleton.SafeThreadAsyncCall(UpdateParseInfo); }
void ParseInfoUpdated(object sender, ParseInformationEventArgs e) { if (this.editor == null || !FileUtility.IsEqualFileName(this.editor.FileName, e.FileName)) return; var parseInfo = e.NewParseInformation as XamlFullParseInformation; if (parseInfo != null && parseInfo.Document != null) UpdateTree(parseInfo.Document); }
private void ParserService_ParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (_textEditor == null || !FileUtility.IsEqualFileName(_textEditor.FileName, e.FileName)) { return; } trvLayout.Items.Clear(); IVbModuleWrapper wrapper = (IVbModuleWrapper)e.NewUnresolvedFile; TreeViewItem root = new TreeViewItem(); root.Header = GetNodeHeaderWithIcon(wrapper.Module.Name, CompletionImage.Class); TreeViewItem fields = new TreeViewItem(); root.Items.Add(fields); TreeViewItem properties = new TreeViewItem(); root.Items.Add(properties); TreeViewItem methods = new TreeViewItem(); root.Items.Add(methods); foreach (IVbMember member in wrapper.Module.Members) { TreeViewItem memberNode = new TreeViewItem(); memberNode.Header = member.Name; memberNode.Tag = member; memberNode.Selected += memberNode_Selected; if (member is IVbProperty) { properties.Items.Add(memberNode); } else if (member is IVbMethod) { methods.Items.Add(memberNode); } else if (member is IVbField) { fields.Items.Add(memberNode); } } fields.Header = GetNodeHeaderWithIcon(string.Format("Fields ({0})", fields.Items.Count), CompletionImage.Field); properties.Header = GetNodeHeaderWithIcon(string.Format("Properties ({0})", properties.Items.Count), CompletionImage.Property); methods.Header = GetNodeHeaderWithIcon(string.Format("Methods ({0})", methods.Items.Count), CompletionImage.Method); root.ExpandSubtree(); trvLayout.Items.Add(root); }
void ParseInfoUpdated(object sender, ParseInformationEventArgs e) { if (this.editor == null || !FileUtility.IsEqualFileName(this.editor.FileName, e.FileName)) return; var parseInfo = e.NewParseInformation as CSharpFullParseInformation; if (parseInfo != null && parseInfo.SyntaxTree != null) { this.updateTreeTimer.Stop(); this.syntaxTree = parseInfo.SyntaxTree; this.updateTreeTimer.Start(); } }
static void ParserService_ParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (e.NewUnresolvedFile == SD.ParserService.GetExistingUnresolvedFile(e.FileName)) { // Call UpdateCommentTags only for the main parse information (if a file is in multiple projects), // and only if the results haven't already been replaced with a more recent ParseInformation. if (e.NewParseInformation != null) { UpdateCommentTags(e.FileName, e.NewParseInformation.TagComments); } else { UpdateCommentTags(e.FileName, new List<TagComment>()); } } }
void ParserServiceParseInformationUpdated(object sender, ParseInformationEventArgs e) { WorkbenchSingleton.DebugAssertMainThread(); foreach (TreeNode node in classBrowserTreeView.Nodes) { AbstractProjectNode prjNode = node as AbstractProjectNode; if (prjNode != null && e.ProjectContent.Project == prjNode.Project) { prjNode.UpdateParseInformation(e.OldCompilationUnit, e.NewCompilationUnit); } } }
public override void OnParseInformationUpdated(ParseInformationEventArgs args) { var c = projectContentContainer; if (c != null) { c.ParseInformationUpdated(args.OldUnresolvedFile, args.NewUnresolvedFile); } // OnParseInformationUpdated is called inside a lock, but we don't want to raise the event inside that lock. // To ensure events are raised in the same order, we always invoke on the main thread. SD.MainThread.InvokeAsyncAndForget(delegate { ParseInformationUpdated(null, args); }); }
void OnParseInformationUpdated(object sender, ParseInformationEventArgs e) { System.Diagnostics.Debug.WriteLine("ClassDiagramViewContent.OnParseInformationUpdated"); if (e == null) { return; } if (e.NewCompilationUnit == null) { return; } if (e.NewCompilationUnit.ProjectContent == null) { return; } if (e.NewCompilationUnit.ProjectContent.Classes == null) { return; } if (e.NewCompilationUnit.ProjectContent != projectContent) { return; } //TODO - this is a wrong way to handle changed parse informtation. // the correct way is to mark removed classes as missing, and to // update changed classes that exist in the diagram. /* * List<CanvasItem> addedItems = new List<CanvasItem>(); * foreach (IClass ct in e.CompilationUnit.ProjectContent.Classes) * { * if (!canvas.Contains(ct)) * { * ClassCanvasItem item = ClassCanvas.CreateItemFromType(ct); * canvas.AddCanvasItem(item); * addedItems.Add(item); * } * } * * WorkbenchSingleton.SafeThreadAsyncCall<ICollection<CanvasItem>>(PlaceNewItems, addedItems); * * foreach (CanvasItem ci in canvas.GetCanvasItems()) * { * ClassCanvasItem cci = ci as ClassCanvasItem; * if (cci != null) * { * if (!e.CompilationUnit.ProjectContent.Classes.Contains(cci.RepresentedClassType)) * canvas.RemoveCanvasItem(cci); * } * } */ }
void ParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (SD.ParserService.LoadSolutionProjectsThread.IsRunning) { return; } if (!e.FileName.Equals(editor.FileName)) { return; } currentReferences = null; textView.InvalidateLayer(KnownLayer.Selection); }
void ParseInfoUpdated(object sender, ParseInformationEventArgs e) { if (this.editor == null || !FileUtility.IsEqualFileName(this.editor.FileName, e.FileName)) { return; } var parseInfo = e.NewParseInformation as XamlFullParseInformation; if (parseInfo != null && parseInfo.Document != null) { UpdateTree(parseInfo.Document); } }
void OnParseInformationChanged(object sender, ParseInformationEventArgs e) { // To prevent some NullReferenceException (possibly when the user switch between editors) if (this.ParentEditor == null || this.ParentEditor.DisplayBinding == null || e == null) { return; } if (this.ParentEditor.DisplayBinding.ContentName != e.FileName) { return; } lastCu = e.ParseInformation.MostRecentCompilationUnit; UpdateAutocorTimer(); }
void ParserService_ParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (FileUtility.IsEqualFileName(e.FileName, document.FileName) && invalidLines.Count > 0) { cachedLines.Clear(); foreach (IDocumentLine line in invalidLines) { if (!line.IsDeleted) { OnHighlightingStateChanged(line.LineNumber, line.LineNumber); } } invalidLines.Clear(); } }
void ParseInfoUpdated(object sender, ParseInformationEventArgs e) { if (this.editor == null || !FileUtility.IsEqualFileName(this.editor.FileName, e.FileName)) { return; } if (!e.IsPrimaryParseInfoForFile) { return; } var cu = e.NewCompilationUnit as XamlCompilationUnit; if (cu != null && cu.TreeRootNode != null) { UpdateTree(cu.TreeRootNode); } }
void SD_ParserService_ParseInformationUpdated(object sender, ParseInformationEventArgs e) { var parseInfo = e.NewParseInformation as CSharpFullParseInformation; ITextSourceVersion currentVersion = editor.Document.Version; if (parseInfo == null) { return; } ITextSourceVersion parsedVersion = parseInfo.ParsedVersion; if (parsedVersion != null && currentVersion != null && parsedVersion.BelongsToSameDocumentAs(currentVersion)) { if (analyzedVersion != null && analyzedVersion.CompareAge(parsedVersion) == 0) { // don't analyze the same version twice return; } RunAnalysis(editor.Document.CreateSnapshot(), parseInfo); } }
void ParserServiceParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (e.FileName != this.FileName) { return; } this.VerifyAccess(); // When parse information is updated quickly in succession, only do a single update // to the latest version. updateParseInfoTo = e.NewParseInformation; this.Dispatcher.BeginInvoke( DispatcherPriority.Background, new Action( delegate { if (updateParseInfoTo != null) { ParseInformationUpdated(updateParseInfoTo); updateParseInfoTo = null; } })); }
public void ParserServiceParseInformationUpdated(object sender, ParseInformationEventArgs e) { lock (pending) { pending.Add(new ICompilationUnit[] { e.ParseInformation.MostRecentCompilationUnit as ICompilationUnit, e.CompilationUnit}); } WorkbenchSingleton.SafeThreadAsyncCall(UpdateThread); }
private void UpdateClassBrowser(object sender, ParseInformationEventArgs args) { // This event handler can get called when files other than the current content are updated. eg. // when loading a new document. If we didn't do this check the member combo for this tab would have // methods for a different class in it! if (ContentName == args.FileName && !handlingParseEvent) { handlingParseEvent = true; memberParseInfo = args.ParseInformation; GLib.Timeout.Add (1000, new GLib.TimeoutHandler (BindClassCombo)); } }
void OnParserUpdateStep(object sender, ParseInformationEventArgs e) { UpdateTick(e); }
void OnParseInformationChanged (object sender, ParseInformationEventArgs e) { // To prevent some NullReferenceException (possibly when the user switch between editors) if (this.ParentEditor == null || this.ParentEditor.DisplayBinding == null || e == null) return; if (this.ParentEditor.DisplayBinding.ContentName != e.FileName) return; lastCu = e.ParseInformation.MostRecentCompilationUnit; UpdateAutocorTimer (); }
void SD_ParserService_ParseInformationUpdated(object sender, ParseInformationEventArgs e) { var parseInfo = e.NewParseInformation as CSharpFullParseInformation; ITextSourceVersion currentVersion = editor.Document.Version; if (parseInfo == null) return; ITextSourceVersion parsedVersion = parseInfo.ParsedVersion; if (parsedVersion != null && currentVersion != null && parsedVersion.BelongsToSameDocumentAs(currentVersion)) { if (analyzedVersion != null && analyzedVersion.CompareAge(parsedVersion) == 0) { // don't analyze the same version twice return; } RunAnalysis(editor.Document.CreateSnapshot(), parseInfo); } }
void ParserServiceParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (e.FileName != this.FileName) return; this.VerifyAccess(); // When parse information is updated quickly in succession, only do a single update // to the latest version. updateParseInfoTo = e.NewParseInformation; this.Dispatcher.BeginInvoke( DispatcherPriority.Background, new Action( delegate { if (updateParseInfoTo != null) { ParseInformationUpdated(updateParseInfoTo); updateParseInfoTo = null; } })); }
void ParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (SD.ParserService.LoadSolutionProjectsThread.IsRunning) return; if (!e.FileName.Equals(editor.FileName)) return; currentReferences = null; textView.InvalidateLayer(KnownLayer.Selection); }
public virtual void OnParseInformationUpdated(ParseInformationEventArgs args) { throw new NotSupportedException(); }