コード例 #1
0
        public virtual int ReplaceAll(string withPattern)
        {
            int result = 0;

            using (var undo = textEditorData.OpenUndoGroup()) {
                int offset = 0;
                if (!SearchRequest.SearchRegion.IsInvalid)
                {
                    offset = SearchRequest.SearchRegion.Offset;
                }
                SearchResult searchResult;
                var          text = textEditorData.Text;
                var          args = new SearchWorkerArguments()
                {
                    Text = text
                };
                while (true)
                {
                    searchResult = SearchForward(null, args, offset);
                    if (searchResult == null || searchResult.SearchWrapped)
                    {
                        break;
                    }
                    Replace(searchResult, withPattern);
                    offset = searchResult.EndOffset;
                    result++;
                }
                if (result > 0)
                {
                    textEditorData.ClearSelection();
                }
            }
            return(result);
        }
コード例 #2
0
        public override SearchResult SearchBackward(System.ComponentModel.BackgroundWorker worker, SearchWorkerArguments args, int fromOffset)
        {
            if (regex == null || String.IsNullOrEmpty(searchRequest.SearchPattern))
            {
                return(null);
            }
            System.Text.RegularExpressions.Match found = null;
            System.Text.RegularExpressions.Match last  = null;
            foreach (System.Text.RegularExpressions.Match match in regex.Matches(args.Text))
            {
                if (match.Index < fromOffset)
                {
                    found = match;
                }
                last = match;
            }
            bool wrapped = false;

            if (found == null)
            {
                found   = last;
                wrapped = true;
            }

            if (found != null)
            {
                return(new SearchResult(found.Index, found.Length, wrapped));
            }
            return(null);
        }
コード例 #3
0
 public override SearchResult SearchForward(System.ComponentModel.BackgroundWorker worker, SearchWorkerArguments args, int fromOffset)
 {
     if (regex == null || String.IsNullOrEmpty(searchRequest.SearchPattern))
     {
         return(null);
     }
     System.Text.RegularExpressions.Match match = regex.Match(args.Text, fromOffset);
     if (match.Success)
     {
         return(new SearchResult(match.Index,
                                 match.Length, false));
     }
     match = regex.Match(args.Text, 0, fromOffset);
     if (match.Success)
     {
         return(new SearchResult(match.Index,
                                 match.Length, true));
     }
     return(null);
 }
コード例 #4
0
        public override int ReplaceAll(string withPattern)
        {
            var searchResults = new List <SearchResult> ();

            int offset = 0;

            if (!SearchRequest.SearchRegion.IsInvalid)
            {
                offset = SearchRequest.SearchRegion.Offset;
            }
            SearchResult searchResult;
            var          text = textEditorData.Text;
            var          args = new SearchWorkerArguments()
            {
                Text = text
            };

            while (true)
            {
                searchResult = SearchForward(null, args, offset);
                if (searchResult == null || searchResult.SearchWrapped)
                {
                    break;
                }
                searchResults.Add(searchResult);
                offset = searchResult.EndOffset;
            }
            if (searchResults.Count < 100)
            {
                using (var undo = textEditorData.OpenUndoGroup()) {
                    for (int i = searchResults.Count - 1; i >= 0; i--)
                    {
                        Replace(searchResults [i], withPattern);
                    }
                    if (searchResults.Count > 0)
                    {
                        textEditorData.ClearSelection();
                    }
                }
            }
            else
            {
                char[] oldText = text.ToCharArray();
                char[] newText = new char[oldText.Length + searchResults.Count * (withPattern.Length - compiledPattern.Length)];
                char[] pattern = withPattern.ToCharArray();
                int    curOffset = 0, destOffset = 0;
                foreach (var sr in searchResults)
                {
                    var length = sr.Offset - curOffset;
                    Array.Copy(oldText, curOffset, newText, destOffset, length);
                    destOffset += length;
                    Array.Copy(pattern, 0, newText, destOffset, pattern.Length);
                    destOffset += withPattern.Length;
                    curOffset   = sr.EndOffset;
                }
                var l = textEditorData.Length - curOffset;
                Array.Copy(oldText, curOffset, newText, destOffset, l);

                textEditorData.Replace(0, textEditorData.Length, new string (newText));
                textEditorData.ClearSelection();
            }
            return(searchResults.Count);
        }
コード例 #5
0
 public override SearchResult SearchBackward(System.ComponentModel.BackgroundWorker worker, SearchWorkerArguments args, int fromOffset)
 {
     if (!string.IsNullOrEmpty(SearchRequest.SearchPattern))
     {
         // TODO: Optimize
         for (int i = 0; i < args.Text.Length; i++)
         {
             int offset = (fromOffset + args.Text.Length * 2 - 1 - i) % args.Text.Length;
             if (worker != null && worker.CancellationPending)
             {
                 return(null);
             }
             if (IsMatchAt(offset) && (searchRequest.SearchRegion.IsInvalid || searchRequest.SearchRegion.Contains(offset)))
             {
                 return(new SearchResult(offset, searchRequest.SearchPattern.Length, offset > fromOffset));
             }
         }
     }
     return(null);
 }
コード例 #6
0
 public abstract SearchResult SearchBackward(System.ComponentModel.BackgroundWorker worker, SearchWorkerArguments args, int fromOffset);