← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/Gui/ResultsEditorExtension.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/Gui/ResultsEditorExtension.cs
56
56
                
57
57
                public override void Dispose ()
58
58
                {
59
 
                        if (!disposed) {
60
 
                                AnalysisOptions.AnalysisEnabled.Changed -= AnalysisOptionsChanged;
61
 
                                CancelTask ();
62
 
                                disposed = true;
63
 
                        }
64
 
                        base.Dispose ();
 
59
                        if (disposed) 
 
60
                                return;
 
61
                        enabled = false;
 
62
                        Document.DocumentParsed -= OnDocumentParsed;
 
63
                        CancelTask ();
 
64
                        AnalysisOptions.AnalysisEnabled.Changed -= AnalysisOptionsChanged;
 
65
                        while (markers.Count > 0)
 
66
                                Document.Editor.Document.RemoveMarker (markers.Dequeue ());
 
67
                        tasks.Clear ();
 
68
                        disposed = true;
65
69
                }
66
70
                
67
71
                bool enabled;
92
96
                {
93
97
                        if (src != null) {
94
98
                                src.Cancel ();
95
 
                                oldTask.Wait ();
 
99
                                try {
 
100
                                        oldTask.Wait ();
 
101
                                } catch (TaskCanceledException) {
 
102
                                } catch (AggregateException ex) {
 
103
                                        ex.Handle (e => e is TaskCanceledException);
 
104
                                }
96
105
                        }
97
106
                }
98
107
                
116
125
                        var doc = Document.ParsedDocument;
117
126
                        if (doc == null)
118
127
                                return;
119
 
                        if (src != null) {
120
 
                                src.Cancel ();
121
 
                                oldTask.Wait ();
 
128
                        lock (this) {
 
129
                                CancelTask ();
 
130
                                src = new CancellationTokenSource ();
 
131
                                var treeType = new RuleTreeType ("Document", Path.GetExtension (doc.FileName));
 
132
                                var task = AnalysisService.QueueAnalysis (Document, treeType, src.Token);
 
133
                                oldTask = task.ContinueWith (t => new ResultsUpdater (this, t.Result, src.Token).Update (), src.Token);
122
134
                        }
123
 
                        src = new CancellationTokenSource ();
124
 
                        var treeType = new RuleTreeType ("Document", Path.GetExtension (doc.FileName));
125
 
                        var task = AnalysisService.QueueAnalysis (Document, treeType);
126
 
                        oldTask = task.ContinueWith (t => new ResultsUpdater (this, t.Result, src.Token).Update ());
127
135
                }
128
136
                
129
137
                class ResultsUpdater 
149
157
                        
150
158
                        public void Update ()
151
159
                        {
152
 
                                if (!QuickTaskStrip.EnableFancyFeatures)
 
160
                                if (!QuickTaskStrip.EnableFancyFeatures || cancellationToken.IsCancellationRequested)
153
161
                                        return;
154
162
                                ext.tasks.Clear ();
155
163
                                GLib.Idle.Add (IdleHandler);
182
190
                                        var currentResult = (Result)enumerator.Current;
183
191
                                        
184
192
                                        if (currentResult.InspectionMark != IssueMarker.None) {
185
 
                                                var marker = new ResultMarker (currentResult);
186
 
                                                marker.IsVisible = currentResult.Underline;
187
 
                                                editor.Document.AddMarker (marker.Line, marker);
188
 
                                                ext.markers.Enqueue (marker);
 
193
                                                int start = editor.LocationToOffset (currentResult.Region.Begin);
 
194
                                                int end = editor.LocationToOffset (currentResult.Region.End);
 
195
 
 
196
                                                if (currentResult.InspectionMark == IssueMarker.GrayOut) {
 
197
                                                        var marker = new GrayOutMarker (currentResult, TextSegment.FromBounds (start, end));
 
198
                                                        marker.IsVisible = currentResult.Underline;
 
199
                                                        editor.Document.AddMarker (marker);
 
200
                                                        ext.markers.Enqueue (marker);
 
201
                                                        editor.Parent.TextViewMargin.RemoveCachedLine (editor.GetLineByOffset (start));
 
202
                                                        editor.Parent.QueueDraw ();
 
203
                                                } else {
 
204
                                                        var marker = new ResultMarker (currentResult, TextSegment.FromBounds (start, end));
 
205
                                                        marker.IsVisible = currentResult.Underline;
 
206
                                                        editor.Document.AddMarker (marker);
 
207
                                                        ext.markers.Enqueue (marker);
 
208
                                                }
189
209
                                        }
190
210
                                        
191
211
                                        ext.tasks.Add (new QuickTask (currentResult.Message, currentResult.Region.Begin, currentResult.Level));
200
220
                
201
221
                const int UPDATE_COUNT = 20;
202
222
                
203
 
                public IList<Result> GetResultsAtOffset (int offset)
 
223
                public IList<Result> GetResultsAtOffset (int offset, CancellationToken token = default (CancellationToken))
204
224
                {
205
 
                        var location = Editor.Document.OffsetToLocation (offset);
206
 
                        var line = Editor.GetLineByOffset (offset);
 
225
//                      var location = Editor.Document.OffsetToLocation (offset);
 
226
//                      var line = Editor.GetLineByOffset (offset);
207
227
                        
208
228
                        var list = new List<Result> ();
209
 
                        foreach (var marker in line.Markers) {
 
229
                        foreach (var marker in Editor.Document.GetTextSegmentMarkersAt (offset)) {
 
230
                                if (token.IsCancellationRequested)
 
231
                                        break;
210
232
                                var resultMarker = marker as ResultMarker;
211
 
                                if (resultMarker == null || resultMarker.Line != location.Line)
212
 
                                        continue;
213
 
                                int cs = resultMarker.ColStart, ce = resultMarker.ColEnd;
214
 
                                if ((cs >= 0 && cs > location.Column) || (ce >= 0 && ce < location.Column))
215
 
                                        continue;
216
 
                                list.Add (resultMarker.Result);
 
233
                                if (resultMarker != null)
 
234
                                        list.Add (resultMarker.Result);
217
235
                        }
218
236
                        return list;
219
237
                }