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;