← Back to branch summary

~ubuntu-branches/ubuntu/saucy/monodevelop/saucy-proposed

« back to all changes in this revision

Viewing changes to src/core/Mono.Texteditor/Mono.TextEditor/Document/TextDocument.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2012-06-22 20:35:35 UTC
  • mfrom: (10.3.2)
  • Revision ID: package-import@ubuntu.com-20120622203535-zrozwvcf6kfk6l6i
Tags: 3.0.3.2+dfsg-1
* [3fd89ae] Imported Upstream version 3.0.3.2+dfsg
* [379a680] Remove old patches we haven't used for ages from git.
* [d71161d] Remove correct_paths_in_monodevelop-core-addins.pc.patch.
  Upstream claim to have fixed this by moving assembly install locations.
* [15dbfb9] Fix install location for MonoDevelop.Gettext.dll.config.
* [26eb434] Fix install location for MonoDevelop.SourceEditor2.dll.config.
* [4169974] Upstream commit 53282c9 which finally reconciles the 
  MonoDevelop.Gettext.dll install location with the 
  monodevelop-core-addins.pc location.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/Mono.Texteditor/Mono.TextEditor/Document/TextDocument.cs
33
33
using System.Linq;
34
34
using System.ComponentModel;
35
35
using ICSharpCode.NRefactory.Editor;
 
36
using System.Threading.Tasks;
 
37
using System.Threading;
36
38
 
37
39
namespace Mono.TextEditor
38
40
{
140
142
                        };
141
143
                }
142
144
 
143
 
                ~TextDocument ()
144
 
                {
145
 
                        if (foldSegmentWorker != null) {
146
 
                                foldSegmentWorker.Dispose ();
147
 
                                foldSegmentWorker = null;
148
 
                        }
149
 
                }
150
 
 
151
145
                void SplitterLineSegmentTreeLineChanged (object sender, LineEventArgs e)
152
146
                {
153
147
                        if (LineChanged != null)
979
973
                }
980
974
                
981
975
                readonly object syncObject = new object();
982
 
                BackgroundWorker foldSegmentWorker = null;
983
 
                BackgroundWorker FoldSegmentWorker {
984
 
                        get {
985
 
                                if (foldSegmentWorker == null) {
986
 
                                        foldSegmentWorker = new BackgroundWorker ();
987
 
                                        foldSegmentWorker.WorkerSupportsCancellation = true;
988
 
                                        foldSegmentWorker.DoWork += UpdateFoldSegmentWorker;
989
 
                                }
990
 
                                return foldSegmentWorker;
991
 
                        }
992
 
                }
993
 
                
994
 
                public void UpdateFoldSegments (List<FoldSegment> newSegments)
995
 
                {
996
 
                        UpdateFoldSegments (newSegments, true);
997
 
                }
998
 
                
999
 
 
1000
 
                public void UpdateFoldSegments (List<FoldSegment> newSegments, bool runInThread)
 
976
 
 
977
                CancellationTokenSource foldSegmentSrc;
 
978
                Task foldSegmentTask;
 
979
 
 
980
                public void UpdateFoldSegments (List<FoldSegment> newSegments, bool startTask = false, bool useApplicationInvoke = false)
1001
981
                {
1002
982
                        if (newSegments == null) {
1003
983
                                return;
1004
984
                        }
 
985
                        Console.WriteLine ("startTask={0}, useApplicationInvoke={1}", startTask, useApplicationInvoke);
1005
986
                        
1006
987
                        InterruptFoldWorker ();
1007
 
                        if (!runInThread) {
1008
 
                                UpdateFoldSegmentWorker (null, new DoWorkEventArgs (newSegments));
 
988
                        bool update;
 
989
                        if (!startTask) {
 
990
                                var newFoldedSegments = UpdateFoldSegmentWorker (newSegments, out update);
 
991
                                if (useApplicationInvoke) {
 
992
                                        Gtk.Application.Invoke (delegate {
 
993
                                                foldedSegments = newFoldedSegments;
 
994
                                                InformFoldTreeUpdated ();
 
995
                                        });
 
996
                                } else {
 
997
                                        foldedSegments = newFoldedSegments;
 
998
                                        InformFoldTreeUpdated ();
 
999
                                }
1009
1000
                                return;
1010
1001
                        }
1011
 
                        FoldSegmentWorker.RunWorkerAsync (newSegments);
 
1002
                        foldSegmentSrc = new CancellationTokenSource ();
 
1003
                        var token = foldSegmentSrc.Token;
 
1004
                        foldSegmentTask = Task.Factory.StartNew (delegate {
 
1005
                                var segments = UpdateFoldSegmentWorker (newSegments, out update, token);
 
1006
                                if (token.IsCancellationRequested)
 
1007
                                        return;
 
1008
                                Gtk.Application.Invoke (delegate {
 
1009
                                        if (token.IsCancellationRequested)
 
1010
                                                return;
 
1011
                                        foldedSegments = segments;
 
1012
                                        InformFoldTreeUpdated ();
 
1013
                                        if (update)
 
1014
                                                CommitUpdateAll ();
 
1015
                                });
 
1016
                        }, token);
1012
1017
                }
1013
1018
                
1014
1019
                void RemoveFolding (FoldSegment folding)
1023
1028
                /// Updates the fold segments in a background worker thread. Don't call this method outside of a background worker.
1024
1029
                /// Use UpdateFoldSegments instead.
1025
1030
                /// </summary>
1026
 
                public void UpdateFoldSegmentWorker (object sender, DoWorkEventArgs e)
 
1031
                HashSet<FoldSegment> UpdateFoldSegmentWorker (List<FoldSegment> newSegments, out bool update, CancellationToken token = default(CancellationToken))
1027
1032
                {
1028
 
                        var worker = sender as BackgroundWorker;
1029
 
                        var newSegments = (List<FoldSegment>)e.Argument;
1030
1033
                        var oldSegments = new List<FoldSegment> (FoldSegments);
1031
1034
                        int oldIndex = 0;
1032
1035
                        bool foldedSegmentAdded = false;
1033
1036
                        newSegments.Sort ();
1034
1037
                        var newFoldedSegments = new HashSet<FoldSegment> ();
1035
1038
                        foreach (FoldSegment newFoldSegment in newSegments) {
1036
 
                                if (worker != null && worker.CancellationPending)
1037
 
                                        return;
 
1039
                                if (token.IsCancellationRequested) {
 
1040
                                        update = false;
 
1041
                                        return null;
 
1042
                                }
1038
1043
                                int offset = newFoldSegment.Offset;
1039
1044
                                while (oldIndex < oldSegments.Count && offset > oldSegments [oldIndex].Offset) {
1040
1045
                                        RemoveFolding (oldSegments [oldIndex]);
1073
1078
                                }
1074
1079
                        }
1075
1080
                        while (oldIndex < oldSegments.Count) {
 
1081
                                if (token.IsCancellationRequested) {
 
1082
                                        update = false;
 
1083
                                        return null;
 
1084
                                }
1076
1085
                                RemoveFolding (oldSegments [oldIndex]);
1077
1086
                                oldIndex++;
1078
1087
                        }
1079
1088
                        bool countChanged = foldedSegments.Count != newFoldedSegments.Count;
1080
 
                        if (worker != null) {
1081
 
                                Gtk.Application.Invoke (delegate {
1082
 
                                        foldedSegments = newFoldedSegments;
1083
 
                                        InformFoldTreeUpdated ();
1084
 
                                        if (foldedSegmentAdded || countChanged)
1085
 
                                                CommitUpdateAll ();
1086
 
                                });
1087
 
                        } else {
1088
 
                                foldedSegments = newFoldedSegments;
1089
 
                                InformFoldTreeUpdated ();
1090
 
                        }
 
1089
                        update = foldedSegmentAdded || countChanged;
 
1090
                        return newFoldedSegments;
1091
1091
                }
1092
1092
                
1093
1093
                public void WaitForFoldUpdateFinished ()
1094
1094
                {
1095
 
                        while (FoldSegmentWorker.IsBusy)
1096
 
                                System.Threading.Thread.Sleep (10);
 
1095
                        if (foldSegmentTask != null) {
 
1096
                                foldSegmentTask.Wait (5000);
 
1097
                                foldSegmentTask = null;
 
1098
                        }
1097
1099
                }
1098
1100
                
1099
1101
                void InterruptFoldWorker ()
1100
1102
                {
1101
 
                        if (!FoldSegmentWorker.IsBusy)
 
1103
                        if (foldSegmentSrc == null)
1102
1104
                                return;
1103
 
                        FoldSegmentWorker.CancelAsync ();
 
1105
                        foldSegmentSrc.Cancel ();
1104
1106
                        WaitForFoldUpdateFinished ();
 
1107
                        foldSegmentSrc = null;
1105
1108
                }
1106
1109
                
1107
1110
                public void ClearFoldSegments ()
1159
1162
                
1160
1163
                public int GetLineCount (FoldSegment segment)
1161
1164
                {
1162
 
                        return OffsetToLineNumber(segment.EndLine.Offset) - OffsetToLineNumber(segment.StartLine.Offset);
 
1165
                        return segment.EndLine.LineNumber - segment.StartLine.LineNumber;
1163
1166
                }
1164
1167
                
1165
1168
                public void EnsureOffsetIsUnfolded (int offset)
1391
1394
                
1392
1395
                public void CommitLineUpdate (DocumentLine line)
1393
1396
                {
1394
 
                        CommitLineUpdate (this.OffsetToLineNumber (line.Offset));
 
1397
                        CommitLineUpdate (line.LineNumber);
1395
1398
                }
1396
1399
 
1397
1400
                public void CommitUpdateAll ()
1419
1422
                }
1420
1423
                
1421
1424
                public static bool IsWordSeparator (char ch)
1422
 
 
1423
1425
                {
1424
 
 
1425
1426
                        return Char.IsWhiteSpace (ch) || (Char.IsPunctuation (ch) && ch != '_');
1426
 
 
1427
1427
                }
1428
1428
 
1429
 
                
1430
 
 
1431
1429
                public bool IsWholeWordAt (int offset, int length)
1432
 
 
1433
1430
                {
1434
1431
                        return (offset == 0 || IsWordSeparator (GetCharAt (offset - 1))) &&
1435
1432
                                   (offset + length == TextLength || IsWordSeparator (GetCharAt (offset + length)));