public EditorPositionState(double verticalOffset, double horizontalOffset, TextViewPosition textViewPosition, double DesiredXPos)
 {
     this.VerticalOffset = verticalOffset;
     this.HorizontalOffset = horizontalOffset;
     this.TextViewPosition = textViewPosition;
     this.DesiredXPos = DesiredXPos;
 }

		public override Selection StartSelectionOrSetEndpoint(TextViewPosition startPosition, TextViewPosition endPosition)
		{
			var document = textArea.Document;
			if (document == null)
				throw ThrowUtil.NoDocumentAssigned();
			return Create(textArea, startPosition, endPosition);
		}

		/// <summary>
		/// Creates a new SimpleSelection instance.
		/// </summary>
		internal SimpleSelection(TextArea textArea, TextViewPosition start, TextViewPosition end)
			: base(textArea)
		{
			this.start = start;
			this.end = end;
			this.startOffset = textArea.Document.GetOffset(start.Location);
			this.endOffset = textArea.Document.GetOffset(end.Location);
		}

		static double GetXPos(TextArea textArea, TextViewPosition pos)
		{
			DocumentLine documentLine = textArea.Document.GetLineByNumber(pos.Line);
			VisualLine visualLine = textArea.TextView.GetOrConstructVisualLine(documentLine);
			int vc = visualLine.ValidateVisualColumn(pos, true);
			TextLine textLine = visualLine.GetTextLine(vc);
			return visualLine.GetTextLineVisualXPosition(textLine, vc);
		}

		internal static Selection Create(TextArea textArea, TextViewPosition start, TextViewPosition end)
		{
			if (textArea == null)
				throw new ArgumentNullException("textArea");
			if (textArea.Document.GetOffset(start.Location) == textArea.Document.GetOffset(end.Location) && start.VisualColumn == end.VisualColumn)
				return textArea.emptySelection;
			else
				return new SimpleSelection(textArea, start, end);
		}

        internal Caret(TextArea textArea)
        {
            this.textArea = textArea;
            this.textView = textArea.TextView;
            position = new TextViewPosition(1, 1, 0);

            caretAdorner = new CaretLayer(textView);
            textView.InsertLayer(caretAdorner, KnownLayer.Caret, LayerInsertionPosition.Replace);
            textView.VisualLinesChanged += TextView_VisualLinesChanged;
            textView.ScrollOffsetChanged += TextView_ScrollOffsetChanged;
        }

 RectangleSelection(TextArea textArea, int startLine, double startXPos, TextViewPosition end)
     : base(textArea)
 {
     InitDocument();
     this.startLine = startLine;
     endLine = end.Line;
     this.startXPos = startXPos;
     endXPos = GetXPos(textArea, end);
     CalculateSegments();
     topLeftOffset = segments.First().StartOffset;
     bottomRightOffset = segments.Last().EndOffset;
 }

        private static IEnumerable<Tuple<int, int>> GetOffsetForLinesInSegmentOnScreen(TextView textView, ISegment segment,
            bool extendToFullWidthAtLineEnd = false)
        {
            var segmentStart = segment.Offset;
            var segmentEnd = segment.Offset + segment.Length;

            if (segmentStart > textView.TextDocument.TextLength)
            {
                segmentStart = textView.TextDocument.TextLength;
            }

            if (segmentEnd > textView.TextDocument.TextLength)
            {
                segmentEnd = textView.TextDocument.TextLength;
            }

            var start = new TextViewPosition(textView.TextDocument.GetLocation(segmentStart));
            var end = new TextViewPosition(textView.TextDocument.GetLocation(segmentEnd));

            foreach (var line in textView.VisualLines)
            {
                if (!line.DocumentLine.IsDeleted)
                {
                    if (line.Offset > segmentEnd)
                    {
                        break;
                    }

                    if (line.EndOffset < segmentStart)
                    {
                        continue;
                    }

                    // find start and begining in current line.
                    var lineStartOffset = line.Offset;

                    if (segment.Offset > line.Offset)
                    {
                        lineStartOffset = line.Offset + (segment.Offset - line.Offset);
                    }

                    var lineEndOffset = line.EndOffset;

                    if (segment.EndOffset < line.EndOffset)
                    {
                        lineEndOffset = line.EndOffset - (line.EndOffset - segment.EndOffset);
                    }

                    // generate rect for section in this line.
                    yield return new Tuple<int, int>(lineStartOffset, lineEndOffset);
                }
            }
        }

 private RectangleSelection(TextArea textArea, TextViewPosition start, int endLine, double endXPos)
     : base(textArea)
 {
     InitDocument();
     this.startLine = start.Line;
     this.endLine = endLine;
     this.startXPos = GetXPos(textArea, start);
     this.endXPos = endXPos;
     CalculateSegments();
     this.topLeftOffset = this.segments.First().StartOffset;
     this.bottomRightOffset = this.segments.Last().EndOffset;
 }

        public static Rect GetViewPortPosition(TextView textView, int offset)
        {
            var position = new TextViewPosition(textView.GetLocation(offset));

            if (position.Line > 0)
            {
                return GetTextPositionInViewPort(textView, position);
            }
            else
            {
                return new Rect();
            }
        }

        public static string GetWordUnderMouse(this TextDocument document, TextViewPosition position)
        {
            string wordHovered = string.Empty;

            var line = position.Line;
            var column = position.Column;

            var offset = document.GetOffset(line, column);
            if (offset >= document.TextLength)
                offset--;

            var textAtOffset = document.GetText(offset, 1);

            // Get text backward of the mouse position, until the first space
            while (!string.IsNullOrWhiteSpace(textAtOffset))
            {
                wordHovered = textAtOffset + wordHovered;

                offset--;

                if (offset < 0)
                    break;

                textAtOffset = document.GetText(offset, 1);
            }

            // Get text forward the mouse position, until the first space
            offset = document.GetOffset(line, column);
            if (offset < document.TextLength - 1)
            {
                offset++;

                textAtOffset = document.GetText(offset, 1);

                while (!string.IsNullOrWhiteSpace(textAtOffset))
                {
                    wordHovered = wordHovered + textAtOffset;

                    offset++;

                    if (offset >= document.TextLength)
                        break;

                    textAtOffset = document.GetText(offset, 1);
                }
            }

            return wordHovered;
        }

        public static Rect GetTextPositionInViewPort(TextView textView, TextViewPosition position)
        {
            if (position.Line - 1 < textView.VisualLines.Count)
            {
                return new Rect(textView.VisualLines[position.Line - 1].RenderedText.HitTestTextPosition(position.Column - 1).X + textView.TextSurfaceBounds.X,
                    textView.CharSize.Height * (position.Line - 1),
                    textView.CharSize.Width,
                    textView.CharSize.Height);
            }

            return new Rect(textView.TextSurfaceBounds.X + textView.CharSize.Width * (position.Column - 1),
                textView.CharSize.Height * (position.Line - 1),
                textView.CharSize.Width,
                textView.CharSize.Height);
        }

		internal string AddSpacesIfRequired(string newText, TextViewPosition start, TextViewPosition end)
		{
			if (EnableVirtualSpace && InsertVirtualSpaces(newText, start, end)) {
				var line = textArea.Document.GetLineByNumber(start.Line);
				string lineText = textArea.Document.GetText(line);
				var vLine = textArea.TextView.GetOrConstructVisualLine(line);
				int colDiff = start.VisualColumn - vLine.VisualLengthWithEndOfLineMarker;
				if (colDiff > 0) {
					string additionalSpaces = "";
					if (!textArea.Options.ConvertTabsToSpaces && lineText.Trim('\t').Length == 0) {
						int tabCount = (int)(colDiff / textArea.Options.IndentationSize);
						additionalSpaces = new string('\t', tabCount);
						colDiff -= tabCount * textArea.Options.IndentationSize;
					}
					additionalSpaces += new string(' ', colDiff);
					return additionalSpaces + newText;
				}
			}
			return newText;
		}

        public static string GetWordUnderMouse(this TextDocument document, TextViewPosition position, bool cancelDot)
        {
            string wordHovered = string.Empty;
            int line = position.Line;
            int column = position.Column;
            int offset = document.GetOffset(line, column);
            if (offset >= document.TextLength)
                offset--;
            string textAtOffset = document.GetText(offset, 1);

            // Get text backward of the mouse position, until the first space
            while (!string.IsNullOrWhiteSpace(textAtOffset) && !StringContainsBreaks(textAtOffset, true))
            {
                wordHovered = textAtOffset + wordHovered;
                offset--;
                if (offset < 0)
                    break;
                textAtOffset = document.GetText(offset, 1);
            }

            // Get text forward the mouse position, until the first space
            offset = document.GetOffset(line, column);
            if (offset < document.TextLength - 1) {
                offset++;

                textAtOffset = document.GetText(offset, 1);
                while (!string.IsNullOrWhiteSpace(textAtOffset) && !StringContainsBreaks(textAtOffset, false)) {
                    wordHovered = wordHovered + textAtOffset;
                    offset++;
                    if (offset >= document.TextLength)
                        break;
                    textAtOffset = document.GetText(offset, 1);
                }
            }
            return wordHovered;
        }

 bool InsertVirtualSpaces(string newText, TextViewPosition start, TextViewPosition end)
 {
     return (!string.IsNullOrEmpty(newText) || !(IsInVirtualSpace(start) && IsInVirtualSpace(end)))
         && newText != "\r\n"
         && newText != "\n"
         && newText != "\r";
 }

 /// <summary>
 /// If this selection is empty, starts a new selection from <paramref name="startPosition"/> to
 /// <paramref name="endPosition"/>, otherwise, changes the endpoint of this selection.
 /// </summary>
 public abstract Selection StartSelectionOrSetEndpoint(TextViewPosition startPosition, TextViewPosition endPosition);

 /// <summary>
 /// Returns a new selection with the changed end point.
 /// </summary>
 /// <exception cref="NotSupportedException">Cannot set endpoint for empty selection</exception>
 public abstract Selection SetEndpoint(TextViewPosition endPosition);

 static Rect GetCharacterBounds(this TextView textView, TextViewPosition pos, HwndSource source)
 {
     VisualLine vl = textView.GetVisualLine(pos.Line);
     if (vl == null)
         return EMPTY_RECT;
     // this may happen during layout changes in AvalonDock, so we just return an empty rectangle
     // in those cases. It should be refreshed immediately.
     if (source.RootVisual == null || !source.RootVisual.IsAncestorOf(textView))
         return EMPTY_RECT;
     TextLine line = vl.GetTextLine(pos.VisualColumn);
     Rect displayRect;
     // calculate the display rect for the current character
     if (pos.VisualColumn < vl.VisualLengthWithEndOfLineMarker) {
         displayRect = line.GetTextBounds(pos.VisualColumn, 1).First().Rectangle;
         displayRect.Offset(0, vl.GetTextLineVisualYPosition(line, VisualYPosition.LineTop));
     } else {
         // if we are in virtual space, we just use one wide-space as character width
         displayRect = new Rect(vl.GetVisualPosition(pos.VisualColumn, VisualYPosition.TextTop),
                                new Size(textView.WideSpaceWidth, textView.DefaultLineHeight));
     }
     // adjust to current scrolling
     displayRect.Offset(-textView.ScrollOffset);
     return textView
         .TransformToAncestor(source.RootVisual).TransformBounds(displayRect) // rect on root visual
         .TransformToDevice(source.RootVisual); // rect on HWND
 }

 /// <inheritdoc/>
 public override Selection StartSelectionOrSetEndpoint(TextViewPosition startPosition, TextViewPosition endPosition)
 {
     return SetEndpoint(endPosition);
 }

        /// <summary>
        /// Positions the completion window at the specified position.
        /// </summary>
        protected void SetPosition(TextViewPosition position)
        {
            TextView textView = this.TextArea.TextView;

            visualLocation = textView.GetVisualPosition(position, VisualYPosition.LineBottom);
            visualLocationTop = textView.GetVisualPosition(position, VisualYPosition.LineTop);
            UpdatePosition();
        }