833 lines
24 KiB
C#
833 lines
24 KiB
C#
#region Using Directives
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Text.RegularExpressions;
|
|
|
|
#endregion Using Directives
|
|
|
|
|
|
namespace ScintillaNET
|
|
{
|
|
[TypeConverterAttribute(typeof(System.ComponentModel.ExpandableObjectConverter))]
|
|
public class FindReplace : TopLevelHelper
|
|
{
|
|
#region Fields
|
|
|
|
private Indicator _indicator;
|
|
private Marker _marker;
|
|
private SearchFlags _flags;
|
|
private FindReplaceDialog _window;
|
|
private IncrementalSearcher _incrementalSearcher;
|
|
private List<Range> _lastReplaceAllMatches = new List<Range>();
|
|
private string _lastReplaceAllReplaceString = "";
|
|
private Range _lastReplaceAllRangeToSearch = null;
|
|
private int _lastReplaceAllOffset = 0;
|
|
|
|
#endregion Fields
|
|
|
|
|
|
#region Methods
|
|
|
|
public void ClearAllHighlights()
|
|
{
|
|
Indicator i = Scintilla.FindReplace.Indicator;
|
|
foreach (Range r in i.SearchAll())
|
|
{
|
|
r.ClearIndicator(i);
|
|
}
|
|
}
|
|
|
|
|
|
public Range Find(int startPos, int endPos, Regex findExpression)
|
|
{
|
|
return Find(new Range(startPos, endPos, Scintilla), findExpression, false);
|
|
}
|
|
|
|
|
|
public Range Find(int startPos, int endPos, Regex findExpression, bool searchUp)
|
|
{
|
|
return Find(new Range(startPos, endPos, Scintilla), findExpression, searchUp);
|
|
}
|
|
|
|
|
|
public unsafe Range Find(int startPos, int endPos, string searchString, SearchFlags flags)
|
|
{
|
|
TextToFind ttf = new TextToFind();
|
|
ttf.chrg.cpMin = startPos;
|
|
ttf.chrg.cpMax = endPos;
|
|
|
|
fixed (byte* pb = Scintilla.Encoding.GetBytes(searchString))
|
|
{
|
|
ttf.lpstrText = (IntPtr)pb;
|
|
int pos = NativeScintilla.FindText((int)flags, ref ttf);
|
|
if (pos >= 0)
|
|
{
|
|
return new Range(pos, pos + searchString.Length, Scintilla);
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public Range Find(Range r, Regex findExpression)
|
|
{
|
|
return Find(r, findExpression, false);
|
|
}
|
|
|
|
|
|
public Range Find(Range r, Regex findExpression, bool searchUp)
|
|
{
|
|
// Single line and Multi Line in RegExp doesn't really effect
|
|
// whether or not a match will include newline charaters. This
|
|
// means we can't do a line by line search. We have to search
|
|
// the entire range becuase it could potentially match the
|
|
// entire range.
|
|
|
|
Match m = findExpression.Match(r.Text);
|
|
|
|
if (!m.Success)
|
|
return null;
|
|
|
|
if (searchUp)
|
|
{
|
|
// Since we can't search backwards with RegExp we
|
|
// have to search the entire string and return the
|
|
// last match. Not the most efficient way of doing
|
|
// things but it works.
|
|
Range range = null;
|
|
while (m.Success)
|
|
{
|
|
range = new Range(r.Start + m.Index, r.Start + m.Index + m.Length, Scintilla);
|
|
m = m.NextMatch();
|
|
}
|
|
return range;
|
|
}
|
|
|
|
return new Range(r.Start + m.Index, r.Start + m.Index + m.Length, Scintilla);
|
|
}
|
|
|
|
|
|
public Range Find(Range rangeToSearch, string searchString)
|
|
{
|
|
return Find(rangeToSearch.Start, rangeToSearch.End, searchString, _flags);
|
|
}
|
|
|
|
|
|
public Range Find(Range rangeToSearch, string searchString, bool searchUp)
|
|
{
|
|
if (searchUp)
|
|
return Find(rangeToSearch.End, rangeToSearch.Start, searchString, _flags);
|
|
else
|
|
return Find(rangeToSearch.Start, rangeToSearch.End, searchString, _flags);
|
|
}
|
|
|
|
|
|
public Range Find(Range rangeToSearch, string searchString, SearchFlags searchflags)
|
|
{
|
|
return Find(rangeToSearch.Start, rangeToSearch.End, searchString, searchflags);
|
|
}
|
|
|
|
|
|
public Range Find(Range rangeToSearch, string searchString, SearchFlags searchflags, bool searchUp)
|
|
{
|
|
if (searchUp)
|
|
return Find(rangeToSearch.End, rangeToSearch.Start, searchString, searchflags);
|
|
else
|
|
return Find(rangeToSearch.Start, rangeToSearch.End, searchString, searchflags);
|
|
}
|
|
|
|
|
|
public Range Find(Regex findExpression)
|
|
{
|
|
return Find(new Range(0, NativeScintilla.GetTextLength(), Scintilla), findExpression, false);
|
|
}
|
|
|
|
|
|
public Range Find(Regex findExpression, bool searchUp)
|
|
{
|
|
return Find(new Range(0, NativeScintilla.GetTextLength(), Scintilla), findExpression, searchUp);
|
|
}
|
|
|
|
|
|
public Range Find(string searchString)
|
|
{
|
|
return Find(0, NativeScintilla.GetTextLength(), searchString, _flags);
|
|
}
|
|
|
|
|
|
public Range Find(string searchString, bool searchUp)
|
|
{
|
|
if (searchUp)
|
|
return Find(NativeScintilla.GetTextLength(), 0, searchString, _flags);
|
|
else
|
|
return Find(0, NativeScintilla.GetTextLength(), searchString, _flags);
|
|
}
|
|
|
|
|
|
public Range Find(string searchString, SearchFlags searchflags)
|
|
{
|
|
return Find(0, NativeScintilla.GetTextLength(), searchString, searchflags);
|
|
}
|
|
|
|
|
|
public Range Find(string searchString, SearchFlags searchflags, bool searchUp)
|
|
{
|
|
if (searchUp)
|
|
return Find(NativeScintilla.GetTextLength(), 0, searchString, searchflags);
|
|
else
|
|
return Find(0, NativeScintilla.GetTextLength(), searchString, searchflags);
|
|
}
|
|
|
|
|
|
public List<Range> FindAll(int startPos, int endPos, Regex findExpression)
|
|
{
|
|
return FindAll(new Range(startPos, endPos, Scintilla), findExpression);
|
|
}
|
|
|
|
|
|
public List<Range> FindAll(int startPos, int endPos, string searchString, SearchFlags flags)
|
|
{
|
|
List<Range> res = new List<Range>();
|
|
|
|
while (true)
|
|
{
|
|
Range r = Find(startPos, endPos, searchString, flags);
|
|
if (r == null)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
res.Add(r);
|
|
startPos = r.End;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
public List<Range> FindAll(Range rangeToSearch, Regex findExpression)
|
|
{
|
|
List<Range> res = new List<Range>();
|
|
|
|
while (true)
|
|
{
|
|
Range r = Find(rangeToSearch, findExpression);
|
|
if (r == null)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
res.Add(r);
|
|
rangeToSearch = new Range(r.End, rangeToSearch.End, Scintilla);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
public List<Range> FindAll(Range rangeToSearch, string searchString)
|
|
{
|
|
return FindAll(rangeToSearch.Start, rangeToSearch.End, searchString, _flags);
|
|
}
|
|
|
|
|
|
public List<Range> FindAll(Range rangeToSearch, string searchString, SearchFlags flags)
|
|
{
|
|
return FindAll(rangeToSearch.Start, rangeToSearch.End, searchString, _flags);
|
|
}
|
|
|
|
|
|
public List<Range> FindAll(Regex findExpression)
|
|
{
|
|
return FindAll(0, NativeScintilla.GetTextLength(), findExpression);
|
|
}
|
|
|
|
|
|
public List<Range> FindAll(string searchString)
|
|
{
|
|
return FindAll(searchString, _flags);
|
|
}
|
|
|
|
|
|
public List<Range> FindAll(string searchString, SearchFlags flags)
|
|
{
|
|
return FindAll(0, NativeScintilla.GetTextLength(), searchString, flags);
|
|
}
|
|
|
|
|
|
public Range FindNext(Regex findExpression)
|
|
{
|
|
return FindNext(findExpression, false);
|
|
}
|
|
|
|
|
|
public Range FindNext(Regex findExpression, bool wrap)
|
|
{
|
|
Range r = Find(NativeScintilla.GetCurrentPos(), NativeScintilla.GetTextLength(), findExpression);
|
|
if (r != null)
|
|
return r;
|
|
else if (wrap)
|
|
return Find(0, NativeScintilla.GetCurrentPos(), findExpression);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
public Range FindNext(Regex findExpression, bool wrap, Range searchRange)
|
|
{
|
|
int caret = Scintilla.Caret.Position;
|
|
if (!searchRange.PositionInRange(caret))
|
|
return Find(searchRange.Start, searchRange.End, findExpression, false);
|
|
|
|
Range r = Find(caret, searchRange.End, findExpression);
|
|
if (r != null)
|
|
return r;
|
|
else if (wrap)
|
|
return Find(searchRange.Start, caret, findExpression);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
public Range FindNext(string searchString)
|
|
{
|
|
return FindNext(searchString, true, _flags);
|
|
}
|
|
|
|
|
|
public Range FindNext(string searchString, bool wrap)
|
|
{
|
|
return FindNext(searchString, wrap, _flags);
|
|
}
|
|
|
|
|
|
public Range FindNext(string searchString, bool wrap, SearchFlags flags)
|
|
{
|
|
Range r = Find(NativeScintilla.GetCurrentPos(), NativeScintilla.GetTextLength(), searchString, flags);
|
|
if (r != null)
|
|
return r;
|
|
else if (wrap)
|
|
return Find(0, NativeScintilla.GetCurrentPos(), searchString, flags);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
public Range FindNext(string searchString, bool wrap, SearchFlags flags, Range searchRange)
|
|
{
|
|
int caret = Scintilla.Caret.Position;
|
|
if (!searchRange.PositionInRange(caret))
|
|
return Find(searchRange.Start, searchRange.End, searchString, flags);
|
|
|
|
Range r = Find(caret, searchRange.End, searchString, flags);
|
|
if (r != null)
|
|
return r;
|
|
else if (wrap)
|
|
return Find(searchRange.Start, caret, searchString, flags);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
public Range FindNext(string searchString, SearchFlags flags)
|
|
{
|
|
return FindNext(searchString, true, flags);
|
|
}
|
|
|
|
|
|
public Range FindPrevious(Regex findExpression)
|
|
{
|
|
return FindPrevious(findExpression, false);
|
|
}
|
|
|
|
|
|
public Range FindPrevious(Regex findExpression, bool wrap)
|
|
{
|
|
Range r = Find(0, NativeScintilla.GetAnchor(), findExpression, true);
|
|
if (r != null)
|
|
return r;
|
|
else if (wrap)
|
|
return Find(NativeScintilla.GetCurrentPos(), NativeScintilla.GetTextLength(), findExpression, true);
|
|
else
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
public Range FindPrevious(Regex findExpression, bool wrap, Range searchRange)
|
|
{
|
|
int caret = Scintilla.Caret.Position;
|
|
if (!searchRange.PositionInRange(caret))
|
|
return Find(searchRange.Start, searchRange.End, findExpression, true);
|
|
|
|
int anchor = Scintilla.Caret.Anchor;
|
|
if (!searchRange.PositionInRange(anchor))
|
|
anchor = caret;
|
|
|
|
Range r = Find(searchRange.Start, anchor, findExpression, true);
|
|
if (r != null)
|
|
return r;
|
|
else if (wrap)
|
|
return Find(anchor, searchRange.End, findExpression, true);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
public Range FindPrevious(string searchString)
|
|
{
|
|
return FindPrevious(searchString, true, _flags);
|
|
}
|
|
|
|
|
|
public Range FindPrevious(string searchString, bool wrap)
|
|
{
|
|
return FindPrevious(searchString, wrap, _flags);
|
|
}
|
|
|
|
|
|
public Range FindPrevious(string searchString, bool wrap, SearchFlags flags)
|
|
{
|
|
Range r = Find(NativeScintilla.GetAnchor(), 0, searchString, flags);
|
|
if (r != null)
|
|
return r;
|
|
else if (wrap)
|
|
return Find(NativeScintilla.GetTextLength(), NativeScintilla.GetCurrentPos(), searchString, flags);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
public Range FindPrevious(string searchString, bool wrap, SearchFlags flags, Range searchRange)
|
|
{
|
|
int caret = Scintilla.Caret.Position;
|
|
if (!searchRange.PositionInRange(caret))
|
|
return Find(searchRange.End, searchRange.Start, searchString, flags);
|
|
|
|
int anchor = Scintilla.Caret.Anchor;
|
|
if (!searchRange.PositionInRange(anchor))
|
|
anchor = caret;
|
|
|
|
Range r = Find(anchor, searchRange.Start, searchString, flags);
|
|
if (r != null)
|
|
return r;
|
|
else if (wrap)
|
|
return Find(searchRange.End, anchor, searchString, flags);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
public Range FindPrevious(string searchString, SearchFlags flags)
|
|
{
|
|
return FindPrevious(searchString, true, flags);
|
|
}
|
|
|
|
|
|
public void HighlightAll(IList<Range> foundRanges)
|
|
{
|
|
foreach (Range r in foundRanges)
|
|
{
|
|
r.SetIndicator(Indicator.Number);
|
|
}
|
|
}
|
|
|
|
|
|
public void IncrementalSearch()
|
|
{
|
|
_incrementalSearcher.Show();
|
|
}
|
|
|
|
|
|
public List<MarkerInstance> MarkAll(IList<Range> foundRanges)
|
|
{
|
|
List<MarkerInstance> ret = new List<MarkerInstance>();
|
|
|
|
Line lastLine = new Line(Scintilla, -1);
|
|
foreach (Range r in foundRanges)
|
|
{
|
|
// We can of course have multiple instances of a find on a single
|
|
// line. We don't want to mark this line more than once.
|
|
Line line = r.StartingLine;
|
|
if (line.Number > lastLine.Number)
|
|
ret.Add(Marker.AddInstanceTo(r.StartingLine));
|
|
lastLine = line;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
public List<Range> ReplaceAll(int startPos, int endPos, Regex findExpression, string replaceString)
|
|
{
|
|
return ReplaceAll(new Range(startPos, endPos, Scintilla), findExpression, replaceString);
|
|
}
|
|
|
|
|
|
public List<Range> ReplaceAll(int startPos, int endPos, string searchString, string replaceString, SearchFlags flags)
|
|
{
|
|
List<Range> ret = new List<Range>();
|
|
|
|
Scintilla.UndoRedo.BeginUndoAction();
|
|
|
|
int diff = replaceString.Length - searchString.Length;
|
|
while (true)
|
|
{
|
|
Range r = Find(startPos, endPos, searchString, flags);
|
|
if (r == null)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
r.Text = replaceString;
|
|
r.End = startPos = r.Start + replaceString.Length;
|
|
endPos += diff;
|
|
|
|
ret.Add(r);
|
|
}
|
|
}
|
|
|
|
Scintilla.UndoRedo.EndUndoAction();
|
|
return ret;
|
|
}
|
|
|
|
|
|
public List<Range> ReplaceAll(Range rangeToSearch, Regex findExpression, string replaceString)
|
|
{
|
|
Scintilla.UndoRedo.BeginUndoAction();
|
|
|
|
// I tried using an anonymous delegate for this but it didn't work too well.
|
|
// It's too bad because it was a lot cleaner than using member variables as
|
|
// psuedo globals.
|
|
_lastReplaceAllMatches = new List<Range>();
|
|
_lastReplaceAllReplaceString = replaceString;
|
|
_lastReplaceAllRangeToSearch = rangeToSearch;
|
|
_lastReplaceAllOffset = 0;
|
|
|
|
findExpression.Replace(rangeToSearch.Text, new MatchEvaluator(ReplaceAllEvaluator));
|
|
|
|
Scintilla.UndoRedo.EndUndoAction();
|
|
|
|
// No use having these values hanging around wasting memory :)
|
|
List<Range> ret = _lastReplaceAllMatches;
|
|
_lastReplaceAllMatches = null;
|
|
_lastReplaceAllReplaceString = null;
|
|
_lastReplaceAllRangeToSearch = null;
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
public List<Range> ReplaceAll(Range rangeToSearch, string searchString, string replaceString)
|
|
{
|
|
return ReplaceAll(rangeToSearch.Start, rangeToSearch.End, searchString, replaceString, _flags);
|
|
}
|
|
|
|
|
|
public List<Range> ReplaceAll(Range rangeToSearch, string searchString, string replaceString, SearchFlags flags)
|
|
{
|
|
return ReplaceAll(rangeToSearch.Start, rangeToSearch.End, searchString, replaceString, _flags);
|
|
}
|
|
|
|
|
|
public List<Range> ReplaceAll(Regex findExpression, string replaceString)
|
|
{
|
|
return ReplaceAll(0, NativeScintilla.GetTextLength(), findExpression, replaceString);
|
|
}
|
|
|
|
|
|
public List<Range> ReplaceAll(string searchString, string replaceString)
|
|
{
|
|
return ReplaceAll(searchString, replaceString, _flags);
|
|
}
|
|
|
|
|
|
public List<Range> ReplaceAll(string searchString, string replaceString, SearchFlags flags)
|
|
{
|
|
return ReplaceAll(0, NativeScintilla.GetTextLength(), searchString, replaceString, flags);
|
|
}
|
|
|
|
|
|
private string ReplaceAllEvaluator(Match m)
|
|
{
|
|
// So this method is called for every match
|
|
|
|
// We make a replacement in the range based upon
|
|
// the match range.
|
|
string replacement = m.Result(_lastReplaceAllReplaceString);
|
|
int start = _lastReplaceAllRangeToSearch.Start + m.Index + _lastReplaceAllOffset;
|
|
int end = start + m.Length;
|
|
|
|
Range r = new Range(start, end, Scintilla);
|
|
_lastReplaceAllMatches.Add(r);
|
|
r.Text = replacement;
|
|
|
|
// But because we've modified the document, the RegEx
|
|
// match ranges are going to be different from the
|
|
// document ranges. We need to compensate
|
|
_lastReplaceAllOffset += replacement.Length - m.Value.Length;
|
|
return replacement;
|
|
}
|
|
|
|
|
|
public Range ReplaceNext(string searchString, string replaceString)
|
|
{
|
|
return ReplaceNext(searchString, replaceString, true, _flags);
|
|
}
|
|
|
|
|
|
public Range ReplaceNext(string searchString, string replaceString, bool wrap)
|
|
{
|
|
return ReplaceNext(searchString, replaceString, wrap, _flags);
|
|
}
|
|
|
|
|
|
public Range ReplaceNext(string searchString, string replaceString, bool wrap, SearchFlags flags)
|
|
{
|
|
Range r = FindNext(searchString, wrap, flags);
|
|
|
|
if (r != null)
|
|
{
|
|
r.Text = replaceString;
|
|
r.End = r.Start + replaceString.Length;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
|
|
public Range ReplaceNext(string searchString, string replaceString, SearchFlags flags)
|
|
{
|
|
return ReplaceNext(searchString, replaceString, true, flags);
|
|
}
|
|
|
|
|
|
public Range ReplacePrevious(string searchString, string replaceString)
|
|
{
|
|
return ReplacePrevious(searchString, replaceString, true, _flags);
|
|
}
|
|
|
|
|
|
public Range ReplacePrevious(string searchString, string replaceString, bool wrap)
|
|
{
|
|
return ReplacePrevious(searchString, replaceString, wrap, _flags);
|
|
}
|
|
|
|
|
|
public Range ReplacePrevious(string searchString, string replaceString, bool wrap, SearchFlags flags)
|
|
{
|
|
Range r = FindPrevious(searchString, wrap, flags);
|
|
|
|
if (r != null)
|
|
{
|
|
r.Text = replaceString;
|
|
r.End = r.Start + replaceString.Length;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
|
|
public Range ReplacePrevious(string searchString, string replaceString, SearchFlags flags)
|
|
{
|
|
return ReplacePrevious(searchString, replaceString, true, flags);
|
|
}
|
|
|
|
|
|
private void ResetFlags()
|
|
{
|
|
_flags = SearchFlags.Empty;
|
|
}
|
|
|
|
|
|
private void ResetIndicator()
|
|
{
|
|
_indicator.Reset();
|
|
}
|
|
|
|
|
|
private void ResetMarker()
|
|
{
|
|
_marker.Reset();
|
|
_marker.Number = 10;
|
|
}
|
|
|
|
|
|
internal bool ShouldSerialize()
|
|
{
|
|
return ShouldSerializeFlags() ||
|
|
ShouldSerializeIndicator() ||
|
|
ShouldSerializeMarker();
|
|
}
|
|
|
|
|
|
private bool ShouldSerializeFlags()
|
|
{
|
|
return _flags != SearchFlags.Empty;
|
|
}
|
|
|
|
|
|
private bool ShouldSerializeIndicator()
|
|
{
|
|
return _indicator.Number != 16 || _indicator.Color != Color.Purple || _indicator.IsDrawnUnder;
|
|
}
|
|
|
|
|
|
private bool ShouldSerializeMarker()
|
|
{
|
|
return _marker.Number != 10 || _marker.ForeColor != Color.White || _marker.BackColor != Color.Black || _marker.Symbol != MarkerSymbol.Arrows;
|
|
}
|
|
|
|
|
|
public void ShowFind()
|
|
{
|
|
if (!_window.Visible)
|
|
_window.Show(Scintilla.FindForm());
|
|
|
|
_window.tabAll.SelectedTab = _window.tabAll.TabPages["tpgFind"];
|
|
|
|
Range selRange = Scintilla.Selection.Range;
|
|
if (selRange.IsMultiLine)
|
|
{
|
|
_window.chkSearchSelectionF.Checked = true;
|
|
}
|
|
else if (selRange.Length > 0)
|
|
{
|
|
_window.cboFindF.Text = selRange.Text;
|
|
}
|
|
|
|
_window.cboFindF.Select();
|
|
_window.cboFindF.SelectAll();
|
|
|
|
}
|
|
|
|
|
|
public void ShowReplace()
|
|
{
|
|
if (!_window.Visible)
|
|
_window.Show(Scintilla.FindForm());
|
|
|
|
_window.tabAll.SelectedTab = _window.tabAll.TabPages["tpgReplace"];
|
|
|
|
Range selRange = Scintilla.Selection.Range;
|
|
if (selRange.IsMultiLine)
|
|
{
|
|
_window.chkSearchSelectionR.Checked = true;
|
|
}
|
|
else if (selRange.Length > 0)
|
|
{
|
|
_window.cboFindR.Text = selRange.Text;
|
|
}
|
|
|
|
_window.cboFindR.Select();
|
|
_window.cboFindR.SelectAll();
|
|
}
|
|
|
|
#endregion Methods
|
|
|
|
|
|
#region Properties
|
|
|
|
[Editor(typeof(ScintillaNET.Design.FlagEnumUIEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public SearchFlags Flags
|
|
{
|
|
get
|
|
{
|
|
return _flags;
|
|
}
|
|
set
|
|
{
|
|
_flags = value;
|
|
}
|
|
}
|
|
|
|
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public IncrementalSearcher IncrementalSearcher
|
|
{
|
|
get
|
|
{
|
|
return _incrementalSearcher;
|
|
}
|
|
set
|
|
{
|
|
_incrementalSearcher = value;
|
|
}
|
|
}
|
|
|
|
|
|
public Indicator Indicator
|
|
{
|
|
get
|
|
{
|
|
return _indicator;
|
|
}
|
|
set
|
|
{
|
|
_indicator = value;
|
|
}
|
|
}
|
|
|
|
|
|
public Marker Marker
|
|
{
|
|
get
|
|
{
|
|
return _marker;
|
|
}
|
|
set
|
|
{
|
|
_marker = value;
|
|
}
|
|
}
|
|
|
|
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public FindReplaceDialog Window
|
|
{
|
|
get
|
|
{
|
|
return _window;
|
|
}
|
|
set
|
|
{
|
|
_window = value;
|
|
}
|
|
}
|
|
|
|
#endregion Properties
|
|
|
|
|
|
#region Constructors
|
|
|
|
internal FindReplace(Scintilla scintilla) : base(scintilla)
|
|
{
|
|
_marker = scintilla.Markers[10];
|
|
_marker.SetSymbolInternal(MarkerSymbol.Arrows);
|
|
_indicator = scintilla.Indicators[16];
|
|
_indicator.Color = Color.Purple;
|
|
_indicator.Style = IndicatorStyle.RoundBox;
|
|
|
|
_window = new FindReplaceDialog();
|
|
_window.Scintilla = scintilla;
|
|
|
|
_incrementalSearcher = new IncrementalSearcher();
|
|
_incrementalSearcher.Scintilla = scintilla;
|
|
_incrementalSearcher.Visible = false;
|
|
scintilla.Controls.Add(_incrementalSearcher);
|
|
}
|
|
|
|
#endregion Constructors
|
|
}
|
|
}
|
|
|