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;
 }

        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;
     //}
 }

		public List<Range> ReplaceAll(Range rangeToSearch, string searchString, string replaceString, SearchFlags flags)
		{
			return ReplaceAll(rangeToSearch.Start, rangeToSearch.End, searchString, replaceString, _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 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 FindNext(string searchString, SearchFlags flags)
		{
			return FindNext(searchString, true, flags);
		}

		public List<Range> FindAll(Range rangeToSearch, string searchString, SearchFlags flags)
		{
			return FindAll(rangeToSearch.Start, rangeToSearch.End, searchString, _flags);
		}

 private bool IsSetInSearchFlags(SearchFlags searchFlagBit)
 {
     this.InitializeSearchFlags();
     return ((this.searchFlags & searchFlagBit) != SearchFlags.None);
 }

 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 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);
		}

 private void SetBitInSearchFlags(SearchFlags searchFlagBit)
 {
     this.InitializeSearchFlags();
     this.searchFlags |= searchFlagBit;
     if (this.isBound)
     {
         this.GetSchemaPropertyDirectoryEntry();
         this.propertyEntry.Properties[PropertyManager.SearchFlags].Value = (int) this.searchFlags;
     }
 }

 private bool HasFlag(SearchFlags flag)
 {
     return _flags.HasFlag(flag);
 }

 private void SetFlag(bool value, SearchFlags flag)
 {
     if (value)
     {
         _flags |= flag;
     }
     else
     {
         _flags &= ~flag;
     }
 }

		private void ResetFlags()
		{
			_flags = SearchFlags.Empty;
		}