void ILineTracker.ChangeComplete(DocumentChangeEventArgs e)
		{
			ILineTracker targetTracker = targetObject.Target as ILineTracker;
			if (targetTracker != null)
				targetTracker.ChangeComplete(e);
			else
				Deregister();
		}

        private void DocumentOnChanged(object sender, DocumentChangeEventArgs e)
        {
            SetCurrent();

            var textChangeRange = new TextChangeRange(
                new TextSpan(e.Offset, e.RemovalLength),
                e.RemovalLength == 0 ? e.InsertionLength : e.RemovalLength);
            OnTextChanged(new TextChangeEventArgs(_before, CurrentText, textChangeRange));
        }

		/// <inheritdoc/>
		public override Selection UpdateOnDocumentChange(DocumentChangeEventArgs e)
		{
			if (e == null)
				throw new ArgumentNullException("e");
			return Selection.Create(
				textArea,
				new TextViewPosition(textArea.Document.GetLocation(e.GetNewOffset(startOffset, AnchorMovementType.Default)), start.VisualColumn),
				new TextViewPosition(textArea.Document.GetLocation(e.GetNewOffset(endOffset, AnchorMovementType.Default)), end.VisualColumn)
			);
		}

        public void ChangeComplete(DocumentChangeEventArgs e)
        {
            if (_lineNumberRemoved > -1)
            {
                _bookmarkManager.AdjustLineOffsets(AdjustTypes.Deleted, _lineNumberRemoved, e.RemovalLength);
                _lineNumberRemoved = -1;
            }

            _bookmarkManager.RecalculateOffsets(_textArea, BookmarkType.Breakpoint, 1);
        }

        private void OnAvDocChanged(object sender, DocumentChangeEventArgs e)
        {
            if (_loading) return;

            _version++;
            Modified = true;
            EventHandler<DocumentChangeEventArgs> handler = Changed;
            if (handler != null)
                handler(sender, e);
        }

		/// <inheritdoc/>
		public override Selection UpdateOnDocumentChange(DocumentChangeEventArgs e)
		{
			if (e == null)
				throw new ArgumentNullException("e");
			TextViewPosition newStart = start;
			TextViewPosition newEnd = end;
			// by changing the existing TextViewPosition, we preserve the VisualColumn (though it might become invalid)
			// and the IsAtEndOfLine property.
			newStart.Location = textArea.Document.GetLocation(e.GetNewOffset(startOffset, AnchorMovementType.Default));
			newEnd.Location   = textArea.Document.GetLocation(e.GetNewOffset(endOffset, AnchorMovementType.Default));
			return Selection.Create(textArea, newStart, newEnd);
		}

		void OnDocumentChanged(DocumentChangeEventArgs e)
		{
			foldings.UpdateOffsets(e);
			FoldingSection s = foldings.FindFirstSegmentWithStartAfter(e.Offset);
			while (s != null && s.StartOffset == e.Offset) {
				FoldingSection next = foldings.GetNextSegment(s);
				if (s.Length == 0) {
					RemoveFolding(s);
				}
				s = next;
			}
		}

        private void DocumentOnChanged(object sender, DocumentChangeEventArgs e)
        {
            if (_updatding) return;

            var oldText = _currentText;

            var textSpan = new TextSpan(e.Offset, e.RemovalLength);
            var textChangeRange = new TextChangeRange(textSpan, e.InsertionLength);
            _currentText = _currentText.WithChanges(new TextChange(textSpan, e.InsertedText?.Text ?? string.Empty));

            TextChanged?.Invoke(this, new TextChangeEventArgs(oldText, _currentText, textChangeRange));
        }

		void OnDocumentChanged(DocumentChangeEventArgs e)
		{
			foldings.UpdateOffsets(e);
			int newEndOffset = e.Offset + e.InsertionLength;
			// extend end offset to the end of the line (including delimiter)
			var endLine = document.GetLineByOffset(newEndOffset);
			newEndOffset = endLine.Offset + endLine.TotalLength;
			foreach (var affectedFolding in foldings.FindOverlappingSegments(e.Offset, newEndOffset - e.Offset)) {
				if (affectedFolding.Length == 0) {
					RemoveFolding(affectedFolding);
				} else {
					affectedFolding.ValidateCollapsedLineSections();
				}
			}
		}

		/// <inheritdoc/>
		public override Selection UpdateOnDocumentChange(DocumentChangeEventArgs e)
		{
			if (e == null)
				throw new ArgumentNullException("e");
			int newStartOffset, newEndOffset;
			if (startOffset <= endOffset) {
				newStartOffset = e.GetNewOffset(startOffset, AnchorMovementType.Default);
				newEndOffset = Math.Max(newStartOffset, e.GetNewOffset(endOffset, AnchorMovementType.BeforeInsertion));
			} else {
				newEndOffset = e.GetNewOffset(endOffset, AnchorMovementType.Default);
				newStartOffset = Math.Max(newEndOffset, e.GetNewOffset(startOffset, AnchorMovementType.BeforeInsertion));
			}
			return Selection.Create(
				textArea,
				new TextViewPosition(textArea.Document.GetLocation(newStartOffset), start.VisualColumn),
				new TextViewPosition(textArea.Document.GetLocation(newEndOffset), end.VisualColumn)
			);
		}

 internal void OnDocumentChanged(DocumentChangeEventArgs e)
 {
     InvalidateVisualColumn();
     if (storedCaretOffset >= 0) {
         int newCaretOffset = e.GetNewOffset(storedCaretOffset, AnchorMovementType.Default);
         TextDocument document = textArea.Document;
         if (document != null) {
             // keep visual column
             this.Position = new TextViewPosition(document.GetLocation(newCaretOffset), position.VisualColumn);
         }
     }
     storedCaretOffset = -1;
 }

 internal void Push(TextDocument document, DocumentChangeEventArgs e)
 {
     if (state == StatePlayback)
         throw new InvalidOperationException("Document changes during undo/redo operations are not allowed.");
     if (state == StatePlaybackModifyDocument)
         state = StatePlayback; // allow only 1 change per expected modification
     else
         Push(new DocumentChangeOperation(document, e));
 }

 void textArea_Document_Changing(object sender, DocumentChangeEventArgs e)
 {
     if (e.Offset + e.RemovalLength == this.StartOffset && e.RemovalLength > 0) {
         Close(); // removal immediately in front of completion segment: close the window
         // this is necessary when pressing backspace after dot-completion
     }
     if (e.Offset == StartOffset && e.RemovalLength == 0 && ExpectInsertionBeforeStart) {
         StartOffset = e.GetNewOffset(StartOffset, AnchorMovementType.AfterInsertion);
         this.ExpectInsertionBeforeStart = false;
     } else {
         StartOffset = e.GetNewOffset(StartOffset, AnchorMovementType.BeforeInsertion);
     }
     EndOffset = e.GetNewOffset(EndOffset, AnchorMovementType.AfterInsertion);
 }

		void DoReplace(int offset, int length, string newText, OffsetChangeMap offsetChangeMap)
		{
			if (length == 0 && newText.Length == 0)
				return;
			
			// trying to replace a single character in 'Normal' mode?
			// for single characters, 'CharacterReplace' mode is equivalent, but more performant
			// (we don't have to touch the anchorTree at all in 'CharacterReplace' mode)
			if (length == 1 && newText.Length == 1 && offsetChangeMap == null)
				offsetChangeMap = OffsetChangeMap.Empty;
			
			string removedText = rope.ToString(offset, length);
			DocumentChangeEventArgs args = new DocumentChangeEventArgs(offset, removedText, newText, offsetChangeMap);
			
			// fire DocumentChanging event
			if (Changing != null)
				Changing(this, args);
			
			cachedText = null; // reset cache of complete document text
			fireTextChanged = true;
			DelayedEvents delayedEvents = new DelayedEvents();
			
			lock (lockObject) {
				// create linked list of checkpoints, if required
				if (currentCheckpoint != null) {
					currentCheckpoint = currentCheckpoint.Append(args);
				}
				
				// now update the textBuffer and lineTree
				if (offset == 0 && length == rope.Length) {
					// optimize replacing the whole document
					rope.Clear();
					rope.InsertText(0, newText);
					lineManager.Rebuild();
				} else {
					rope.RemoveRange(offset, length);
					lineManager.Remove(offset, length);
					#if DEBUG
					lineTree.CheckProperties();
					#endif
					rope.InsertText(offset, newText);
					lineManager.Insert(offset, newText);
					#if DEBUG
					lineTree.CheckProperties();
					#endif
				}
			}
			
			// update text anchors
			if (offsetChangeMap == null) {
				anchorTree.HandleTextChange(args.CreateSingleChangeMapEntry(), delayedEvents);
			} else {
				foreach (OffsetChangeMapEntry entry in offsetChangeMap) {
					anchorTree.HandleTextChange(entry, delayedEvents);
				}
			}
			
			// raise delayed events after our data structures are consistent again
			delayedEvents.RaiseEvents();
			
			// fire DocumentChanged event
			if (Changed != null)
				Changed(this, args);
		}

		void document_Changed(object sender, DocumentChangeEventArgs e)
		{
			if (DocumentChanged != null)
				DocumentChanged(this, e);
		}

 internal ChangeTrackingCheckpoint Append(DocumentChangeEventArgs change)
 {
     Debug.Assert(this.next == null);
     this.next = new ChangeTrackingCheckpoint(this.documentIdentifier, change, unchecked( this.id + 1 ));
     return this.next;
 }

 internal ChangeTrackingCheckpoint(object documentIdentifier, DocumentChangeEventArgs value, int id)
 {
     this.documentIdentifier = documentIdentifier;
     this.value = value;
     this.id = id;
 }

		public override Selection UpdateOnDocumentChange(DocumentChangeEventArgs e)
		{
			return this;
		}

		internal void OnDocumentChanged(DocumentChangeEventArgs e)
		{
			InvalidateVisualColumn();
			if (storedCaretOffset >= 0) {
				// If the caret is at the end of a selection, we don't expand the selection if something
				// is inserted at the end. Thus we also need to keep the caret in front of the insertion.
				AnchorMovementType caretMovementType;
				if (!textArea.Selection.IsEmpty && storedCaretOffset == textArea.Selection.SurroundingSegment.EndOffset)
					caretMovementType = AnchorMovementType.BeforeInsertion;
				else
					caretMovementType = AnchorMovementType.Default;
				int newCaretOffset = e.GetNewOffset(storedCaretOffset, caretMovementType);
				TextDocument document = textArea.Document;
				if (document != null) {
					// keep visual column
					this.Position = new TextViewPosition(document.GetLocation(newCaretOffset), position.VisualColumn);
				}
			}
			storedCaretOffset = -1;
		}

		void document_Changing(object sender, DocumentChangeEventArgs e)
		{
			TextDocument document = (TextDocument)sender;
			Push(new DocumentChangeOperation(document, e));
		}