public void Replace(string textToFind, string textToReplace, Document doc, SearchFlags flags, SearchScope scope, int startPosition, int endPosition)
{
var ed = App.Editor(doc.GetType()) as ITextEditor;
if (lastSettings != null &&
(lastSettings.LastDocument != doc || ed.SelectionStart != lastSettings.LastStartPosition || ed.SelectionEnd != lastSettings.LastEndPosition))
lastSettings = null;
if (lastSettings != null)
{
ed.ReplaceText(lastSettings.LastStartPosition, lastSettings.LastEndPosition, lastSettings.TextToReplace);
lastSettings.LastEndPosition = lastSettings.LastStartPosition + lastSettings.TextToReplace.Length;
}
var res = Search(textToFind, doc, flags, scope, (d,r) => {
var editor = (ITextEditor)App.GetService<IEditorService>().GetEditor(d.GetType()).Instance;
var docServ = App.GetService<IDocumentService>();
if (docServ.GetActiveDocument() != d)
docServ.SetActiveDocument(d);
editor.SelectText(r.StartPosition, r.EndPosition - r.StartPosition);
lastSettings.LastStartPosition = r.StartPosition;
lastSettings.TextToReplace = textToReplace;
var sci = editor.Control as ScintillaControl;
if (sci != null)
sci.PutArrow(sci.GetLineFromPosition(r.StartPosition));
return true;
}, false, lastSettings != null ? lastSettings.LastEndPosition : startPosition, endPosition, null);
IsFinished(res);
}
public SearchReplaceForm()
{
InitializeComponent();
// Initialise the SearchFlags
_findSearchFlags = new SearchFlags();
_replaceSearchFlags = new SearchFlags();
_findSearchFlags = SearchFlags.None;
_replaceSearchFlags = SearchFlags.None;
}
public void Replace(string textToFind, string textToReplace, Document doc, SearchFlags flags, SearchScope scope)
{
if (lastSettings != null)
Replace(textToFind, textToReplace, doc, flags, scope, lastSettings.LastEndPosition, lastSettings.MaxPosition);
else
{
var rootEditor = (ITextEditor)App.GetService<IEditorService>().GetEditor(doc.GetType()).Instance;
var sp = scope == SearchScope.Selection ? rootEditor.SelectionStart :
scope == SearchScope.Current ? rootEditor.CaretPosition : 0;
var ep = scope == SearchScope.Selection ? rootEditor.SelectionEnd : 0;
Replace(textToFind, textToReplace, doc, flags, scope, sp, ep);
}
}
private unsafe SearchResult InternalSearch(SearchFlags flags, string text, int startPosition, int endPosition)
{
fixed (byte* pt = Encoding.UTF8.GetBytes(text))
{
var pf = new TextToFind();
pf.lpstrText = (IntPtr)pt;
pf.chrg.Min = startPosition;
pf.chrg.Max = endPosition <= 0 ? startPosition + scintilla.Ref.Send(Sci.SCI_GETTEXTLENGTH) : endPosition;
var res = RunSearch(flags, ref pf);
if (res == -1)
return SearchResult.NotFound;
else
return new SearchResult(pf.chrgText.Min, pf.chrgText.Max);
}
}
public Query(IntPtr replyHwnd, SearchFlags flags, string searchString)
{
Size = 22 + searchString.Length * 2;
_ptr = Marshal.AllocHGlobal(Size);
var writer = new UnmanagedMemoryWriter(_ptr);
// HWND reply_hwnd
writer.Write((uint)replyHwnd.ToInt64());
// ULONG_PTR reply_copydata_message (ULONG_PTR is defined as unsigned __int3264, but uint seems
// to work here even when running both processes as 64-bit)
writer.Write(0u);
// DWORD search_flags
writer.Write((uint)flags);
// DWORD offset
writer.Write(0u);
// DWORD max_results
writer.Write(uint.MaxValue);
// DWORD search_string[1]
writer.Write(searchString);
}
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 void SetFindParam(string text, SearchFlags searchFlags = SearchFlags.None)
{
if (text != _text || searchFlags != _searchFlags)
{
_text = text;
_searchFlags = searchFlags;
_search = false;
}
//FindNext();
//else if (_positionIndex != -1)
//{
// _positionIndex++;
// if (_positionIndex == _positions.Count)
// _positionIndex = 0;
//}
//if (_positionIndex != -1)
//{
// FindPosition findPosition = _positions[_positionIndex];
// _scintillaControl.GotoPosition(findPosition.Start);
// _scintillaControl.SelectionStart = findPosition.Start;
// _scintillaControl.SelectionEnd = findPosition.End;
//}
}
private bool HasFlag(SearchFlags flag)
{
return _flags.HasFlag(flag);
}
/// <summary>
/// Initiate a search and return all search items matching the search context. Other items can be found later using the asynchronous searches.
/// </summary>
/// <param name="context">The current search context</param>
/// <returns>A list of search items matching the search query.</returns>
public static List <SearchItem> GetItems(SearchContext context, SearchFlags options = SearchFlags.Default)
{
// Stop all search sessions every time there is a new search.
context.sessions.StopAllAsyncSearchSessions();
if (context.actionId == null && string.IsNullOrEmpty(context.searchText) && !context.wantsMore)
{
return(new List <SearchItem>(0));
}
var allItems = new List <SearchItem>(3);
#if QUICKSEARCH_DEBUG
var debugProviderList = context.providers.ToList();
using (new DebugTimer($"Search get items {String.Join(", ", debugProviderList.Select(p=>p.name.id))} -> {context.searchQuery}"));
#endif
foreach (var provider in context.providers)
{
using (var fetchTimer = new DebugTimer(null))
{
try
{
var iterator = provider.fetchItems(context, allItems, provider);
if (iterator != null)
{
if (options.HasFlag(SearchFlags.Synchronous))
{
var stackedEnumerator = new StackedEnumerator <SearchItem>(iterator);
while (stackedEnumerator.MoveNext())
{
if (stackedEnumerator.Current != null)
{
allItems.Add(stackedEnumerator.Current);
}
}
}
else
{
var session = context.sessions.GetProviderSession(provider.name.id);
session.Reset(iterator, k_MaxFetchTimeMs);
if (!session.FetchSome(allItems, k_MaxFetchTimeMs))
{
session.Stop();
}
}
}
provider.RecordFetchTime(fetchTimer.timeMs);
}
catch (Exception ex)
{
UnityEngine.Debug.LogException(new Exception($"Failed to get fetch {provider.name.displayName} provider items.", ex));
}
}
}
if (!options.HasFlag(SearchFlags.Sorted))
{
return(allItems);
}
allItems.Sort(SortItemComparer);
return(allItems.GroupBy(i => i.id).Select(i => i.First()).ToList());
}
private bool IsSetInSearchFlags(SearchFlags searchFlagBit)
{
this.InitializeSearchFlags();
return ((this.searchFlags & searchFlagBit) != SearchFlags.None);
}
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;
}
/// <summary>
/// Initiate a search and return all search items matching the search context. Other items can be found later using the asynchronous searches.
/// </summary>
/// <param name="context">The current search context</param>
/// <returns>A list of search items matching the search query.</returns>
public static List <SearchItem> GetItems(SearchContext context, SearchFlags options = SearchFlags.Default)
{
// Stop all search sessions every time there is a new search.
context.sessions.StopAllAsyncSearchSessions();
context.searchFinishTime = context.searchStartTime = EditorApplication.timeSinceStartup;
context.sessionEnded -= OnSearchEnded;
context.sessionEnded += OnSearchEnded;
#if SHOW_SEARCH_PROGRESS
if (Progress.Exists(context.progressId))
{
Progress.Finish(context.progressId, Progress.Status.Succeeded);
}
context.progressId = Progress.Start($"Searching...", options: Progress.Options.Indefinite);
#endif
if (options.HasFlag(SearchFlags.WantsMore))
{
context.wantsMore = true;
}
var allItems = new List <SearchItem>(3);
#if QUICKSEARCH_DEBUG
var debugProviderList = context.providers.ToList();
using (new DebugTimer($"Search get items {String.Join(", ", debugProviderList.Select(p=>p.name.id))} -> {context.searchQuery}"));
#endif
foreach (var provider in context.providers)
{
try
{
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
var iterator = provider.fetchItems(context, allItems, provider);
if (iterator != null && options.HasFlag(SearchFlags.Synchronous))
{
var stackedEnumerator = new StackedEnumerator <SearchItem>(iterator);
while (stackedEnumerator.MoveNext())
{
if (stackedEnumerator.Current != null)
{
allItems.Add(stackedEnumerator.Current);
}
}
}
else
{
var session = context.sessions.GetProviderSession(context, provider.name.id);
session.Reset(context, iterator, k_MaxFetchTimeMs);
session.Start();
var sessionEnded = !session.FetchSome(allItems, k_MaxFetchTimeMs);
if (options.HasFlag(SearchFlags.FirstBatchAsync))
{
session.SendItems(allItems);
}
if (sessionEnded)
{
session.Stop();
}
}
provider.RecordFetchTime(watch.Elapsed.TotalMilliseconds);
}
catch (Exception ex)
{
UnityEngine.Debug.LogException(new Exception($"Failed to get fetch {provider.name.displayName} provider items.", ex));
}
}
if (!options.HasFlag(SearchFlags.Sorted))
{
return(allItems);
}
allItems.Sort(SortItemComparer);
return(allItems.GroupBy(i => i.id).Select(i => i.First()).ToList());
}
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 FindNext(string searchString, SearchFlags flags)
{
return FindNext(searchString, true, flags);
}
public int ReplaceAll(string searchString, string replaceString, SearchFlags flags, bool Mark, bool Highlight)
{
return(ReplaceAll(0, _scintilla.TextLength, searchString, replaceString, flags, Mark, Highlight));
}
public CharacterRange ReplacePrevious(string searchString, string replaceString, bool wrap, SearchFlags flags)
{
CharacterRange r = FindPrevious(searchString, wrap, flags);
if (r.cpMin != r.cpMax)
{
_scintilla.SelectionStart = r.cpMin;
_scintilla.SelectionEnd = r.cpMax;
_scintilla.ReplaceSelection(replaceString);
r.cpMax = r.cpMin + replaceString.Length;
}
return(r);
}
public SearchExpression(SearchFlags options)
{
m_SearchOptions = options;
Reset();
}
public void TestStringSearch(string search, string str, int expectedStart, int expectedEnd, SearchFlags searchFlags = SearchFlags.NONE)
{
StringSearch.Result expected = new StringSearch.Result(expectedStart, expectedEnd);
StringSearch stringSearch = new StringSearch(search, searchFlags);
StringSearch.Result result1 = stringSearch.SearchIn(str, searchFlags);
StringSearch.Result result2 = StringSearch.Search(search, str, searchFlags);
if (expected.Found)
{
Assert.AreEqual(expected, result1);
Assert.AreEqual(expected, result2);
}
else
{
Assert.IsFalse(result1.Found);
Assert.IsFalse(result2.Found);
}
}
public List <Plugin> GetDisabledPlugins(string query, SearchFlags flags) => GetPluginsOfSearchable(disabledPlugins.Values, query, flags);
private List <Plugin> GetPluginsOfSearchable(IEnumerable <Plugin> searchable, string query, SearchFlags flags)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
Array searchFlags = Enum.GetValues(typeof(SearchFlags));
List <Plugin> plugins = new List <Plugin>();
foreach (Plugin plugin in searchable)
{
if (plugin.Details == null)
{
continue;
}
foreach (SearchFlags flag in searchFlags)
{
// Don't check for match if flag is not specified in flags.
if (!flags.HasFlag(flag))
{
continue;
}
bool match;
switch (flag)
{
case SearchFlags.ID:
match = plugin.Details.id == query;
break;
case SearchFlags.NAME:
match = plugin.Details.name == query;
break;
case SearchFlags.AUTHOR:
match = plugin.Details.author == query;
break;
case SearchFlags.VERSION:
match = plugin.Details.version == query;
break;
case SearchFlags.DESCRIPTION:
match = plugin.Details.description?.Length / 3 <= query.Length && plugin.Details.description.Contains(query);
break;
// It should never get here but it won't compile otherwise.
default:
match = false;
break;
}
if (match)
{
plugins.Add(plugin);
break;
}
}
}
return(plugins);
}
/// <summary>
/// Create a new search context.
/// </summary>
/// <param name="providers">The list of providers used to resolve the specified query.</param>
/// <param name="searchText">The search query to perform.</param>
/// <param name="options">Options to further controlled the query.</param>
public SearchContext(IEnumerable <SearchProvider> providers, string searchText, SearchFlags options)
{
this.providers = providers.ToList();
this.searchText = searchText;
this.options = options;
}
private void ResetFlags()
{
_flags = SearchFlags.Empty;
}
public CharacterRange ReplacePrevious(string searchString, string replaceString, SearchFlags flags)
{
return(ReplacePrevious(searchString, replaceString, true, flags));
}
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 unsafe CharacterRange Find(int startPos, int endPos, string searchString, SearchFlags flags)
{
if (string.IsNullOrEmpty(searchString))
{
return(new CharacterRange());
}
_scintilla.TargetStart = startPos;
_scintilla.TargetEnd = endPos;
_scintilla.SearchFlags = flags;
int pos = _scintilla.SearchInTarget(searchString);
if (pos == -1)
{
return(new CharacterRange());
}
return(new CharacterRange(_scintilla.TargetStart, _scintilla.TargetEnd));
}
public List<Range> FindAll(Range rangeToSearch, string searchString, SearchFlags flags)
{
return FindAll(rangeToSearch.Start, rangeToSearch.End, searchString, _flags);
}
public CharacterRange Find(CharacterRange rangeToSearch, string searchString, SearchFlags searchflags)
{
return(Find(rangeToSearch.cpMin, rangeToSearch.cpMax, searchString, searchflags));
}
public Range FindPrevious(string searchString, SearchFlags flags)
{
return FindPrevious(searchString, true, flags);
}
public CharacterRange Find(CharacterRange rangeToSearch, string searchString, SearchFlags searchflags, bool searchUp)
{
if (searchUp)
{
return(Find(rangeToSearch.cpMax, rangeToSearch.cpMin, searchString, searchflags));
}
else
{
return(Find(rangeToSearch.cpMin, rangeToSearch.cpMax, searchString, searchflags));
}
}
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 CharacterRange Find(string searchString, SearchFlags searchflags)
{
return(Find(0, _scintilla.TextLength, searchString, searchflags));
}
public IEnumerable <MapObject> SearchActors(MapObject instance, SearchFlags flags, Point positionNew)
{
bool includeCharacter = (flags & SearchFlags.Characters) == SearchFlags.Characters;
bool includeMapitems = (flags & SearchFlags.MapItems) == SearchFlags.MapItems;
bool includeNpc = (flags & SearchFlags.Npcs) == SearchFlags.Npcs;
bool includeAlwaysVisible = (flags & SearchFlags.StaticObjects) == SearchFlags.StaticObjects;
if (includeCharacter | includeMapitems | includeNpc == true)
{
List <uint> list = new List <uint>(18);
short by = (short)(instance.region >> 16);
short bx = (short)(instance.region & 0x0000FFFF);
for (int y = -1; y <= 1; y++)
{
for (int x = -1; x <= 1; x++)
{
uint value = (((uint)(by + y) & 0x0000FFFF) << 16) | ((uint)(bx + x) & 0x0000FFFF);
if (!list.Contains(value))
{
list.Add(value);
}
}
}
uint region = GetRegionCode(positionNew);
by = (short)(region >> 16);
bx = (short)(region & 0x0000FFFF);
for (int y = -1; y <= 1; y++)
{
for (int x = -1; x <= 1; x++)
{
uint value = (((uint)(by + y) & 0x0000FFFF) << 16) | ((uint)(bx + x) & 0x0000FFFF);
if (!list.Contains(value))
{
list.Add(value);
}
}
}
for (int a = 0, maxCount = list.Count; a < maxCount; a++)
{
Region fregion;
if (regions.TryGetValue(list[a], out fregion))
{
if (includeMapitems == true)
{
for (int i = 0; i < fregion.mapItems.Count; i++)
{
yield return(fregion.mapItems[i]);
}
}
if (includeCharacter == true)
{
for (int i = 0; i < fregion.characters.Count; i++)
{
yield return(fregion.characters[i]);
}
}
if (includeNpc == true)
{
for (int i = 0; i < fregion.npc.Count; i++)
{
yield return(fregion.npc[i]);
}
}
}
}
}
if (includeAlwaysVisible == true)
{
for (int i = 0; i < alwaysvisible.Count; i++)
{
yield return(alwaysvisible[i]);
}
}
}
public List <CharacterRange> FindAll(int startPos, int endPos, string searchString, SearchFlags flags, bool Mark, bool Highlight)
{
List <CharacterRange> Results = new List <CharacterRange>();
_scintilla.IndicatorCurrent = Indicator.Index;
int findCount = 0;
int lastLine = -1;
while (true)
{
CharacterRange r = Find(startPos, endPos, searchString, flags);
if (r.cpMin == r.cpMax)
{
break;
}
else
{
Results.Add(r);
findCount++;
if (Mark)
{
// 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 = new Line(_scintilla, _scintilla.LineFromPosition(r.cpMin));
if (line.Position > lastLine)
{
line.MarkerAdd(_marker.Index);
}
lastLine = line.Position;
}
if (Highlight)
{
_scintilla.IndicatorFillRange(r.cpMin, r.cpMax - r.cpMin);
}
startPos = r.cpMax;
}
}
//return findCount;
if (FindAllResults != null)
{
FindAllResults(this, new FindResultsEventArgs(this, Results));
}
return(Results);
}
private void InitializeSearchFlags()
{
if (this.isBound && !this.searchFlagsInitialized)
{
object valueFromCache = this.GetValueFromCache(PropertyManager.SearchFlags, false);
if (valueFromCache != null)
{
this.searchFlags = (SearchFlags) ((int) valueFromCache);
}
this.searchFlagsInitialized = true;
}
}
public List <CharacterRange> FindAll(CharacterRange rangeToSearch, string searchString, SearchFlags flags, bool Mark, bool Highlight)
{
return(FindAll(rangeToSearch.cpMin, rangeToSearch.cpMax, searchString, _flags, Mark, Highlight));
}
private void SetBitInSearchFlags(SearchFlags searchFlagBit)
{
this.InitializeSearchFlags();
this.searchFlags |= searchFlagBit;
if (this.isBound)
{
this.GetSchemaPropertyDirectoryEntry();
this.propertyEntry.Properties[PropertyManager.SearchFlags].Value = (int) this.searchFlags;
}
}
public List <CharacterRange> FindAll(string searchString, SearchFlags flags, bool Mark, bool Highlight)
{
return(FindAll(0, _scintilla.TextLength, searchString, flags, Mark, Highlight));
}
private void SetFlag(bool value, SearchFlags flag)
{
if (value)
{
_flags |= flag;
}
else
{
_flags &= ~flag;
}
}
public CharacterRange FindPrevious(string searchString, SearchFlags flags)
{
return(FindPrevious(searchString, true, flags));
}
public Range Find(string searchString, SearchFlags searchflags)
{
return Find(0, NativeScintilla.GetTextLength(), searchString, searchflags);
}
public int ReplaceAll(int startPos, int endPos, string searchString, string replaceString, SearchFlags flags, bool Mark, bool Highlight)
{
_scintilla.IndicatorCurrent = Indicator.Index;
int findCount = 0;
int lastLine = -1;
_scintilla.BeginUndoAction();
int diff = replaceString.Length - searchString.Length;
while (true)
{
CharacterRange r = Find(startPos, endPos, searchString, flags);
if (r.cpMin == r.cpMax)
{
break;
}
else
{
_scintilla.SelectionStart = r.cpMin;
_scintilla.SelectionEnd = r.cpMax;
_scintilla.ReplaceSelection(replaceString);
r.cpMax = startPos = r.cpMin + replaceString.Length;
endPos += diff;
findCount++;
if (Mark)
{
// 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 = new Line(_scintilla, _scintilla.LineFromPosition(r.cpMin));
if (line.Position > lastLine)
{
line.MarkerAdd(_marker.Index);
}
lastLine = line.Position;
}
if (Highlight)
{
_scintilla.IndicatorFillRange(r.cpMin, r.cpMax - r.cpMin);
}
}
}
_scintilla.EndUndoAction();
return(findCount);
}
public Range Find(Range rangeToSearch, string searchString, SearchFlags searchflags)
{
return Find(rangeToSearch.Start, rangeToSearch.End, searchString, searchflags);
}
public int ReplaceAll(CharacterRange rangeToSearch, string searchString, string replaceString, SearchFlags flags, bool Mark, bool Highlight)
{
return(ReplaceAll(rangeToSearch.cpMin, rangeToSearch.cpMax, searchString, replaceString, _flags, Mark, Highlight));
}
public List<Range> FindAll(string searchString, SearchFlags flags)
{
return FindAll(0, NativeScintilla.GetTextLength(), searchString, 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> 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 static bool HasAll(this SearchFlags flags, SearchFlags all) => (flags & all) == all;
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 static SearchContext CreateContext(IEnumerable <SearchProvider> providers, string searchText = "", SearchFlags flags = SearchFlags.Default)
{
return(new SearchContext(providers, searchText, 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;
}
/// <summary>
/// Create context from a list of provider id.
/// </summary>
/// <param name="providerIds">List of provider id</param>
/// <param name="searchQuery">seach Query</param>
/// <returns>New SearchContext</returns>
public static SearchContext CreateContext(IEnumerable <string> providerIds, string searchText = "", SearchFlags flags = SearchFlags.Default)
{
return(new SearchContext(providerIds.Select(id => GetProvider(id)).Where(p => p != null), searchText, flags));
}
public Range ReplacePrevious(string searchString, string replaceString, SearchFlags flags)
{
return ReplacePrevious(searchString, replaceString, true, flags);
}
public IEnumerable <MapObject> SearchActors(MapObject instance, Predicate <MapObject> match, SearchFlags flags)
{
bool includeCharacter = (flags & SearchFlags.Characters) == SearchFlags.Characters;
bool includeMapitems = (flags & SearchFlags.MapItems) == SearchFlags.MapItems;
bool includeNpc = (flags & SearchFlags.Npcs) == SearchFlags.Npcs;
bool includeAlwaysVisible = (flags & SearchFlags.StaticObjects) == SearchFlags.StaticObjects;
if (includeCharacter | includeMapitems | includeNpc == true)
{
foreach (Region fregion in GetNearRegions(instance.region))
{
if (includeMapitems == true)
{
for (int i = 0; i < fregion.mapItems.Count; i++)
{
if (match.Invoke(fregion.mapItems[i]))
{
yield return(fregion.mapItems[i]);
}
}
}
if (includeCharacter == true)
{
for (int i = 0; i < fregion.characters.Count; i++)
{
if (match.Invoke(fregion.mapItems[i]))
{
yield return(fregion.characters[i]);
}
}
}
if (includeNpc == true)
{
for (int i = 0; i < fregion.npc.Count; i++)
{
if (match.Invoke(fregion.npc[i]))
{
yield return(fregion.npc[i]);
}
}
}
}
}
if (includeAlwaysVisible == true)
{
for (int i = 0; i < alwaysvisible.Count; i++)
{
if (match.Invoke(alwaysvisible[i]))
{
yield return(alwaysvisible[i]);
}
}
}
}
public List<Range> ReplaceAll(string searchString, string replaceString, SearchFlags flags)
{
return ReplaceAll(0, NativeScintilla.GetTextLength(), searchString, replaceString, flags);
}
internal static SearchContext CreateContext(string providerId, string searchText = "", SearchFlags flags = SearchFlags.Default)
{
return(CreateContext(new [] { providerId }, searchText, flags));
}
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 static bool HasAny(this SearchFlags flags, SearchFlags f) => (flags & f) != 0;
