public CaretPosition MoveTo(VirtualSnapshotPoint bufferPosition, PositionAffinity caretAffinity) {
            _position = bufferPosition.Position.Position;

            return new CaretPosition(bufferPosition,
                  new MappingPointMock(bufferPosition.Position.Snapshot.TextBuffer, bufferPosition.Position),
                  PositionAffinity.Successor);
        }

		public TextCaret(IWpfTextView textView, IAdornmentLayer caretLayer, ISmartIndentationService smartIndentationService, IClassificationFormatMap classificationFormatMap) {
			if (textView == null)
				throw new ArgumentNullException(nameof(textView));
			if (caretLayer == null)
				throw new ArgumentNullException(nameof(caretLayer));
			if (smartIndentationService == null)
				throw new ArgumentNullException(nameof(smartIndentationService));
			if (classificationFormatMap == null)
				throw new ArgumentNullException(nameof(classificationFormatMap));
			this.textView = textView;
			imeState = new ImeState();
			this.smartIndentationService = smartIndentationService;
			preferredXCoordinate = 0;
			__preferredYCoordinate = 0;
			Affinity = PositionAffinity.Successor;
			currentPosition = new VirtualSnapshotPoint(textView.TextSnapshot, 0);
			textView.TextBuffer.ChangedHighPriority += TextBuffer_ChangedHighPriority;
			textView.TextBuffer.ContentTypeChanged += TextBuffer_ContentTypeChanged;
			textView.Options.OptionChanged += Options_OptionChanged;
			textView.VisualElement.AddHandler(UIElement.GotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(VisualElement_GotKeyboardFocus), true);
			textView.VisualElement.AddHandler(UIElement.LostKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(VisualElement_LostKeyboardFocus), true);
			textView.LayoutChanged += TextView_LayoutChanged;
			textCaretLayer = new TextCaretLayer(this, caretLayer, classificationFormatMap);
			InputMethod.SetIsInputMethodSuspended(textView.VisualElement, true);
		}

        protected override Action GetNewCaretPositionSetter()
        {
            var currentSnapshot = TextView.TextBuffer.CurrentSnapshot;

            var caretPos = TextView.Caret.Position.BufferPosition;
            var caretLine = currentSnapshot.GetLineFromPosition(caretPos.Position);
            int line = currentSnapshot.GetLineNumberFromPosition(caretPos);
            int column = caretPos - caretLine.Start;

            // Get start line of scroll bar
            var scrollBarLine = TextView.TextViewLines.FirstOrDefault(l => l.VisibilityState != VisibilityState.Hidden);
            int scrollBarPos = (scrollBarLine == null) ? 0 : currentSnapshot.GetLineNumberFromPosition(scrollBarLine.Start);
            int maxLine = currentSnapshot.LineCount;

            Action setNewCaretPosition = () =>
                {
                    var newCurrentSnapshot = TextView.TextBuffer.CurrentSnapshot;
                    int newMaxLine = newCurrentSnapshot.LineCount;

                    // Scale caret positions in a linear way
                    int newLine = (int) ((float)line * (float)newMaxLine / (float)maxLine);
                    var newCaretPos = newCurrentSnapshot.GetLineFromLineNumber(newLine).Start.Add(column);
                    var caretPoint = new VirtualSnapshotPoint(newCurrentSnapshot, newCaretPos);
                    TextView.Caret.MoveTo(caretPoint);

                    // Assume that the document scales in a linear way
                    int newScrollBarPos = (int) ((float)scrollBarPos * (float)newMaxLine / (float)maxLine);
                    TextView.ViewScroller.ScrollViewportVerticallyByLines(ScrollDirection.Down, newScrollBarPos);
                };

            return setNewCaretPosition;
        }

			public MouseReferenceInfo(SpanData<ReferenceInfo>? spanData, SpanData<ReferenceInfo>? realSpanData, VirtualSnapshotPoint point) {
				SpanData = spanData;
				RealSpanData = realSpanData;
				virtualSpaces = point.VirtualSpaces;
				position = point.Position.Position;
				versionNumber = point.Position.Snapshot.Version.VersionNumber;
			}

        private void CreateVisuals(VirtualSnapshotPoint caretPosition)
        {
            if ( !settings.CurrentColumnHighlightEnabled ) {
            return; // not enabled
              }
              IWpfTextViewLineCollection textViewLines = view.TextViewLines;
              if ( textViewLines == null )
            return; // not ready yet.
              // make sure the caret position is on the right buffer snapshot
              if ( caretPosition.Position.Snapshot != this.view.TextBuffer.CurrentSnapshot )
            return;

              var line = this.view.GetTextViewLineContainingBufferPosition(
            caretPosition.Position
            );
              var charBounds = line.GetCharacterBounds(caretPosition);

              this.columnRect.Width = charBounds.Width;
              this.columnRect.Height = this.view.ViewportHeight;
              if ( this.columnRect.Height > 2 ) {
            this.columnRect.Height -= 2;
              }

              // Align the image with the top of the bounds of the text geometry
              Canvas.SetLeft(this.columnRect, charBounds.Left);
              Canvas.SetTop(this.columnRect, this.view.ViewportTop);

              layer.AddAdornment(
             AdornmentPositioningBehavior.OwnerControlled, null,
             CUR_COL_TAG, columnRect, null
              );
        }

 public void AddOneOnSameLine1()
 {
     Create("dog cat");
     var point = new VirtualSnapshotPoint(_buffer.GetPoint(0));
     point = VirtualSnapshotPointUtil.AddOneOnSameLine(point);
     Assert.AreEqual(_buffer.GetPoint(1), point.Position);
     Assert.IsFalse(point.IsInVirtualSpace);
 }

 internal static Range.pos GetFSharpPos(VirtualSnapshotPoint point)
 {
     var containingLine = point.Position.GetContainingLine();
     // F# compiler line numbers start at 1
     int lineNumber = containingLine.LineNumber + 1;
     int charIndex = point.Position.Position - containingLine.Start.Position;
     return Range.mkPos(lineNumber, charIndex);
 }

		bool IsInSelection(VirtualSnapshotPoint point) {
			if (wpfTextView.Selection.IsEmpty)
				return false;
			foreach (var span in wpfTextView.Selection.VirtualSelectedSpans) {
				if (span.Contains(point))
					return true;
			}
			return false;
		}

 public void AddOneOnSameLine3()
 {
     Create("dog");
     var point = new VirtualSnapshotPoint(_buffer.GetLine(0).EndIncludingLineBreak, 1);
     point = VirtualSnapshotPointUtil.AddOneOnSameLine(point);
     Assert.AreEqual(_buffer.GetLine(0).EndIncludingLineBreak, point.Position);
     Assert.IsTrue(point.IsInVirtualSpace);
     Assert.AreEqual(2, point.VirtualSpaces);
 }

		MouseLocation(ITextViewLine textViewLine, VirtualSnapshotPoint position, Point point) {
			if (textViewLine == null)
				throw new ArgumentNullException(nameof(textViewLine));
			TextViewLine = textViewLine;
			Position = position;
			Affinity = textViewLine.IsLastTextViewLineForSnapshotLine || position.Position != textViewLine.End ? PositionAffinity.Successor : PositionAffinity.Predecessor;
			Debug.Assert(position.VirtualSpaces == 0 || Affinity == PositionAffinity.Successor);
			Point = point;
		}

        public void MoveCaretToVirtualPoint1()
        {
            var buffer = EditorUtil.CreateBuffer("foo","bar");
            var caret = MockObjectFactory.CreateCaret();
            var textView = MockObjectFactory.CreateTextView(buffer:buffer, caret:caret.Object);
            var point = new VirtualSnapshotPoint(buffer.GetLine(0), 2);

            caret.Setup(x => x.MoveTo(point)).Returns(new CaretPosition()).Verifiable();
            caret.Setup(x => x.EnsureVisible()).Verifiable();
            TextViewUtil.MoveCaretToVirtualPoint(textView.Object, point);
            caret.Verify();
        }

        protected override string GetFormatted(bool isSignatureFile, string source, Fantomas.FormatConfig.FormatConfig config)
        {
            if (isFormattingCursor)
            {
                var caretPos = new VirtualSnapshotPoint(TextView.TextBuffer.CurrentSnapshot, TextView.Caret.Position.BufferPosition);
                Range.pos pos = TextUtils.GetFSharpPos(caretPos);
                return Fantomas.CodeFormatter.formatAroundCursor(isSignatureFile, pos, source, config);
            }

            Range.pos startPos = TextUtils.GetFSharpPos(TextView.Selection.Start);
            Range.pos endPos = TextUtils.GetFSharpPos(TextView.Selection.End);
            Range.range range = Range.mkRange("fsfile", startPos, endPos);

            return Fantomas.CodeFormatter.formatSelectionFromString(isSignatureFile, range, source, config);
        }

		public static Geometry CreateGeometry(IWpfTextView textView, VirtualSnapshotSpan span, bool isMultiLine, bool clipToViewport = false) {
			var padding = isMultiLine ? LineMarkerPadding : TextMarkerPadding;
			var pos = span.Start;
			PathGeometry geo = null;
			bool createOutlinedPath = false;

			while (pos <= span.End) {
				var line = textView.GetTextViewLineContainingBufferPosition(pos.Position);
				bool useVspaces = line.IsLastDocumentLine();
				var lineExtent = new VirtualSnapshotSpan(new VirtualSnapshotPoint(line.Start), new VirtualSnapshotPoint(line.EndIncludingLineBreak, useVspaces ? span.End.VirtualSpaces : 0));
				var extentTmp = lineExtent.Intersection(new VirtualSnapshotSpan(pos, span.End));
				Debug.Assert(extentTmp != null);
				if (line.VisibilityState != VisibilityState.Unattached && extentTmp != null && extentTmp.Value.Length != 0) {
					var extent = extentTmp.Value;
					Collection<TextBounds> textBounds;
					if (extent.Start.IsInVirtualSpace) {
						var leading = line.TextRight + extent.Start.VirtualSpaces * textView.FormattedLineSource.ColumnWidth;
						double width = line.EndOfLineWidth;
						int vspaces = span.End.VirtualSpaces - span.Start.VirtualSpaces;
						if (vspaces > 0)
							width = vspaces * textView.FormattedLineSource.ColumnWidth;
						textBounds = new Collection<TextBounds>();
						textBounds.Add(new TextBounds(leading, line.Top, width, line.Height, line.TextTop, line.TextHeight));
					}
					else if (extent.End.IsInVirtualSpace) {
						textBounds = line.GetNormalizedTextBounds(extent.SnapshotSpan);
						double width = extent.End.VirtualSpaces * textView.FormattedLineSource.ColumnWidth;
						textBounds.Add(new TextBounds(line.TextRight, line.Top, width, line.Height, line.TextTop, line.TextHeight));
					}
					else
						textBounds = line.GetNormalizedTextBounds(extent.SnapshotSpan);
					AddGeometries(textView, textBounds, isMultiLine, clipToViewport, padding, SystemParameters.CaretWidth, ref geo, ref createOutlinedPath);
				}

				if (line.IsLastDocumentLine())
					break;
				pos = new VirtualSnapshotPoint(line.GetPointAfterLineBreak());
			}
			if (createOutlinedPath)
				geo = geo.GetOutlinedPathGeometry();
			if (geo != null && geo.CanFreeze)
				geo.Freeze();
			return geo;
		}

        protected override Action GetNewCaretPositionSetter()
        {
            var caretPos = TextView.Caret.Position.BufferPosition;

            if (isFormattingCursor || caretPos == TextView.Selection.Start.Position)
            {
                int selStartPos = TextView.Selection.Start.Position.Position;

                // Get start line of scroll bar
                var scrollBarLine = TextView.TextViewLines.FirstOrDefault(l => l.VisibilityState != VisibilityState.Hidden);
                int scrollBarPos = (scrollBarLine == null) ? 0 : scrollBarLine.Snapshot.GetLineNumberFromPosition(scrollBarLine.Start);

                Action setNewCaretPosition = () =>
                {
                    // The caret is at the start of selection, its position is unchanged
                    int newSelStartPos = selStartPos;
                    var newActivePoint = new VirtualSnapshotPoint(TextView.TextBuffer.CurrentSnapshot, newSelStartPos);
                    TextView.Caret.MoveTo(newActivePoint);
                    TextView.ViewScroller.ScrollViewportVerticallyByLines(ScrollDirection.Down, scrollBarPos);
                };

                return setNewCaretPosition;
            }
            else
            {
                int selOffsetFromEnd = TextView.TextBuffer.CurrentSnapshot.Length - TextView.Selection.End.Position.Position;

                // Get start line of scroll bar
                var scrollBarLine = TextView.TextViewLines.FirstOrDefault(l => l.VisibilityState != VisibilityState.Hidden);
                int scrollBarPos = (scrollBarLine == null) ? 0 : scrollBarLine.Snapshot.GetLineNumberFromPosition(scrollBarLine.Start);

                Action setNewCaretPosition = () =>
                    {
                        // The caret is at the end of selection, its offset from the end of text is unchanged
                        int newSelEndPos = TextView.TextBuffer.CurrentSnapshot.Length - selOffsetFromEnd;
                        var newAnchorPoint = new VirtualSnapshotPoint(TextView.TextBuffer.CurrentSnapshot, newSelEndPos);

                        TextView.Caret.MoveTo(newAnchorPoint);
                        TextView.ViewScroller.ScrollViewportVerticallyByLines(ScrollDirection.Down, scrollBarPos);
                    };

                return setNewCaretPosition;
            }
        }

        public void MoveCaretToVirtualPoint()
        {
            var buffer = CreateTextBuffer("foo","bar");
            var factory = new MockRepository(MockBehavior.Strict);
            var caret = MockObjectFactory.CreateCaret(factory: factory);
            caret.Setup(x => x.EnsureVisible()).Verifiable();

            var selection = MockObjectFactory.CreateSelection(factory: factory);
            selection.Setup(x => x.Clear()).Verifiable();

            var textView = MockObjectFactory.CreateTextView(
                textBuffer: buffer,
                selection: selection.Object,
                caret: caret.Object,
                factory: factory);
            var point = new VirtualSnapshotPoint(buffer.GetLine(0), 2);
            caret.Setup(x => x.MoveTo(point)).Returns(new CaretPosition()).Verifiable();

            TextViewUtil.MoveCaretToVirtualPoint(textView.Object, point);
            factory.Verify();
        }

        public IExecuteResult Execute(IEnumerable<Node> enodes, IWpfTextView textView, DragDropInfo dragDropInfo)
        {
            var dropLocation = GetDropLocation();
            var nodes = new List<Node>(enodes);
            normaliseNamespaces(dropLocation, nodes);

            var dropAction = getDropAction(nodes, dragDropInfo, dropLocation);

            if (dropAction != null)
            {
                // store the start buffer position
                var droppedPosition = dragDropInfo.VirtualBufferPosition.Position.Position;

                var result =  dropAction.Execute(nodes, textView, dragDropInfo);

                if (result.SelectAfterDrop)
                {

                    var startLine = textView.TextSnapshot.GetLineFromPosition(droppedPosition);
                    if (result.SelectionStartLine > 0)
                    {
                        startLine = textView.TextSnapshot.GetLineFromLineNumber(result.SelectionStartLine);
                    }
                    var start = new VirtualSnapshotPoint(startLine,Math.Max(0,  result.SelectionStartInChars));

                    var endLine = startLine;
                    if (result.SelectionHeightInLines > 1)
                       endLine= textView.TextSnapshot.GetLineFromLineNumber(startLine.LineNumber +
                                                                    result.SelectionHeightInLines - 1);

                    var end = new VirtualSnapshotPoint(endLine, result.SelectionWidthInChars + result.SelectionStartInChars );
                    textView.Selection.Mode = TextSelectionMode.Box;

                    textView.Selection.Select(start, end);
                }
                textView.Caret.MoveTo(textView.Selection.End);

            }
            return ExecuteResult.None ;
        }

        protected CaretHandlerBase(VirtualSnapshotPoint location, int tabSize)
        {
            if (location.Position.Snapshot != null) {
                var line = location.Position.GetContainingLine();
                LineNumber = line.LineNumber;
                Position = location.Position.Position - line.Start.Position + location.VirtualSpaces;

                int bufferIndent = 0;
                int visualIndent = 0;
                foreach (var c in line.GetText().Take(Position)) {
                    if (c == '\t')
                        bufferIndent += tabSize - (bufferIndent % tabSize);
                    else if (c == ' ')
                        bufferIndent += 1;
                    else
                        break;
                    visualIndent += 1;
                }
                Position += bufferIndent - visualIndent;
                Modified = new List<LineSpan>();
            }
        }

		List<VirtualSnapshotSpan> GetSelectedSpans() {
			var list = new List<VirtualSnapshotSpan>();

			if (Mode == TextSelectionMode.Stream)
				list.Add(StreamSelectionSpan);
			else {
				var helper = new BoxSelectionHelper(this);
				var start = Start;
				while (start <= End) {
					var line = TextView.GetTextViewLineContainingBufferPosition(start.Position);
					list.Add(helper.GetSpan(line));
					if (line.IsLastDocumentLine())
						break;
					start = new VirtualSnapshotPoint(line.GetPointAfterLineBreak());
				}
			}

			// At least one span must be included, even if the span's empty
			if (list.Count == 0)
				list.Add(StreamSelectionSpan);

			return list;
		}

		string TryGetSearchStringAtPoint(VirtualSnapshotPoint point) {
			if (point.IsInVirtualSpace)
				return null;

			var extent = textStructureNavigator.GetExtentOfWord(point.Position);
			if (extent.IsSignificant)
				return extent.Span.GetText();

			var line = point.Position.GetContainingLine();
			if (line.Start == point.Position)
				return null;

			extent = textStructureNavigator.GetExtentOfWord(point.Position - 1);
			if (extent.IsSignificant)
				return extent.Span.GetText();

			return null;
		}

 public TextBounds GetExtendedCharacterBounds(VirtualSnapshotPoint bufferPosition) {
     throw new NotImplementedException();
 }