Exemple #1
0
 public void EnsureSpanVisible(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options)
 {
     if (span.Snapshot != textView.TextSnapshot)
     {
         throw new ArgumentException();
     }
     throw new NotImplementedException();            //TODO:
 }
Exemple #2
0
 public static void SelectSpan(
     this ITextView textView,
     SnapshotSpan span,
     IOutliningManagerService outliningManagerService  = null,
     EnsureSpanVisibleOptions ensureSpanVisibleOptions = EnsureSpanVisibleOptions.None)
 {
     textView.TryMoveCaretToAndEnsureVisible(span.Start, outliningManagerService, ensureSpanVisibleOptions);
     textView.Selection.Select(span, isReversed: false);
 }
Exemple #3
0
		public void EnsureSpanVisible(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options) {
			if (span.Snapshot != textView.TextSnapshot)
				throw new ArgumentException();

			if ((textView.TextViewLines?.Count ?? 0) == 0)
				return;

			EnsureSpanVisibleY(span, options);
			EnsureSpanVisibleX(span, options);
		}
Exemple #4
0
 public static bool TryMoveCaretToAndEnsureVisible(
     this ITextView textView,
     SnapshotPoint point,
     IOutliningManagerService outliningManagerService  = null,
     EnsureSpanVisibleOptions ensureSpanVisibleOptions = EnsureSpanVisibleOptions.None)
 {
     return(textView.TryMoveCaretToAndEnsureVisible(
                new VirtualSnapshotPoint(point),
                outliningManagerService,
                ensureSpanVisibleOptions));
 }
Exemple #5
0
        public void EnsureSpanVisible(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options)
        {
            if (span.Snapshot != textView.TextSnapshot)
            {
                throw new ArgumentException();
            }

            if ((textView.TextViewLines?.Count ?? 0) == 0)
            {
                return;
            }

            EnsureSpanVisibleY(span, options);
            EnsureSpanVisibleX(span, options);
        }
Exemple #6
0
 void ShowSpan(SnapshotSpan bufferSpan, EnsureSpanVisibleOptions options)
 {
     if ((options & EnsureSpanVisibleOptions.ShowStart) != 0)
     {
         textView.DisplayTextLineContainingBufferPosition(bufferSpan.Start, 0, ViewRelativePosition.Top);
     }
     else
     {
         var end = bufferSpan.End;
         if (end.Position != 0)
         {
             end = end - 1;
         }
         textView.DisplayTextLineContainingBufferPosition(end, 0, ViewRelativePosition.Bottom);
     }
 }
        void IViewScroller.EnsureSpanVisible(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options)
        {
            // If the textview is closed, this should be a no-op
            if (!IsClosed)
            {
                if ((options & ~(EnsureSpanVisibleOptions.ShowStart | EnsureSpanVisibleOptions.MinimumScroll | EnsureSpanVisibleOptions.AlwaysCenter)) != 0x00)
                {
                    throw new ArgumentOutOfRangeException("options");
                }

                //It is possible that this call is a result of an action that was defered until the view was loaded (& if so, it is possible that the
                //snapshot changed inbetween).
                span = span.TranslateTo(TextSnapshot);

                // TODO: handle the various options for scrolling
                ScrollTo(span.Start.Position);
            }
        }
Exemple #8
0
        public static bool TryMoveCaretToAndEnsureVisible(
            this ITextView textView,
            VirtualSnapshotPoint point,
            IOutliningManagerService outliningManagerService  = null,
            EnsureSpanVisibleOptions ensureSpanVisibleOptions = EnsureSpanVisibleOptions.None)
        {
            if (textView.IsClosed)
            {
                return(false);
            }

            var pointInView = textView.GetPositionInView(point.Position);

            if (!pointInView.HasValue)
            {
                return(false);
            }

            // If we were given an outlining service, we need to expand any outlines first, or else
            // the Caret.MoveTo won't land in the correct location if our target is inside a
            // collapsed outline.
            if (outliningManagerService != null)
            {
                var outliningManager = outliningManagerService.GetOutliningManager(textView);
                if (outliningManager != null)
                {
                    outliningManager.ExpandAll(new SnapshotSpan(pointInView.Value, length: 0), match: _ => true);
                }
            }

            var newPosition = textView.Caret.MoveTo(new VirtualSnapshotPoint(pointInView.Value, point.VirtualSpaces));

            // We use the caret's position in the view's current snapshot here in case something
            // changed text in response to a caret move (e.g. line commit)
            var spanInView = new SnapshotSpan(newPosition.BufferPosition, 0);

            textView.ViewScroller.EnsureSpanVisible(spanInView, ensureSpanVisibleOptions);

            return(true);
        }
 void IViewScroller.EnsureSpanVisible(SnapshotSpan span, EnsureSpanVisibleOptions options)
 {
     ((IViewScroller)this).EnsureSpanVisible(new VirtualSnapshotSpan(span), options);
 }
 public void EnsureSpanVisible(SnapshotSpan span, EnsureSpanVisibleOptions options)
 {
     throw new NotImplementedException();
 }
Exemple #11
0
        void EnsureSpanVisibleY(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options)
        {
            bool showStart     = (options & EnsureSpanVisibleOptions.ShowStart) != 0;
            bool minimumScroll = (options & EnsureSpanVisibleOptions.MinimumScroll) != 0;
            bool alwaysCenter  = (options & EnsureSpanVisibleOptions.AlwaysCenter) != 0;

            var  bufferSpan   = span.SnapshotSpan;
            var  visibleSpan  = VisibleSpan;
            bool spanIsInView = bufferSpan.Start >= visibleSpan.Start && bufferSpan.End <= visibleSpan.End;

            if (!spanIsInView)
            {
                ShowSpan(bufferSpan, options);
                alwaysCenter = true;
                visibleSpan  = VisibleSpan;
                spanIsInView = bufferSpan.Start >= visibleSpan.Start && bufferSpan.End <= visibleSpan.End;
            }

            if (spanIsInView)
            {
                var lines = textView.TextViewLines.GetTextViewLinesIntersectingSpan(bufferSpan);
                Debug.Assert(lines.Count > 0);
                if (lines.Count == 0)
                {
                    return;
                }
                var first     = lines[0];
                var last      = lines[lines.Count - 1];
                var firstSpan = first.ExtentIncludingLineBreak;
                var lastSpan  = last.ExtentIncludingLineBreak;

                bool allLinesFullyVisible = first.VisibilityState == VisibilityState.FullyVisible && last.VisibilityState == VisibilityState.FullyVisible;

                if (alwaysCenter || (!allLinesFullyVisible && !minimumScroll))
                {
                    double height           = last.Bottom - first.Top;
                    double verticalDistance = (textView.ViewportHeight - height) / 2;
                    textView.DisplayTextLineContainingBufferPosition(first.Start, verticalDistance, ViewRelativePosition.Top);
                    return;
                }

                if (first.VisibilityState != VisibilityState.FullyVisible)
                {
                    if (first != last || !minimumScroll || first.VisibilityState != VisibilityState.PartiallyVisible)
                    {
                        textView.DisplayTextLineContainingBufferPosition(first.Start, 0, ViewRelativePosition.Top);
                    }
                    else if (first.Bottom > textView.ViewportBottom)
                    {
                        textView.DisplayTextLineContainingBufferPosition(first.Start, 0, ViewRelativePosition.Bottom);
                    }
                    else
                    {
                        textView.DisplayTextLineContainingBufferPosition(first.Start, 0, ViewRelativePosition.Top);
                    }
                }
                else if (last.VisibilityState != VisibilityState.FullyVisible)
                {
                    textView.DisplayTextLineContainingBufferPosition(last.Start, 0, ViewRelativePosition.Bottom);
                }

                if (showStart)
                {
                    var line = textView.TextViewLines.GetTextViewLineContainingBufferPosition(firstSpan.Start);
                    if (line == null || line.VisibilityState != VisibilityState.FullyVisible)
                    {
                        ShowSpan(bufferSpan, options);
                    }
                }
                else
                {
                    var line = textView.TextViewLines.GetTextViewLineContainingBufferPosition(lastSpan.Start);
                    if (line == null || line.VisibilityState != VisibilityState.FullyVisible)
                    {
                        ShowSpan(bufferSpan, options);
                    }
                }
            }
        }
 public void SelectAndMoveCaret(VirtualSnapshotPoint anchorPoint, VirtualSnapshotPoint activePoint, TextSelectionMode selectionMode, EnsureSpanVisibleOptions? scrollOptions) {
     throw new NotImplementedException();
 }
Exemple #13
0
 public void EnsureSpanVisible(SnapshotSpan span, EnsureSpanVisibleOptions options) =>
 EnsureSpanVisible(new VirtualSnapshotSpan(span), options);
Exemple #14
0
		public void EnsureSpanVisible(SnapshotSpan span, EnsureSpanVisibleOptions options) =>
			EnsureSpanVisible(new VirtualSnapshotSpan(span), options);
Exemple #15
0
		void ShowSpan(SnapshotSpan bufferSpan, EnsureSpanVisibleOptions options) {
			if ((options & EnsureSpanVisibleOptions.ShowStart) != 0)
				textView.DisplayTextLineContainingBufferPosition(bufferSpan.Start, 0, ViewRelativePosition.Top);
			else {
				var end = bufferSpan.End;
				if (end.Position != 0)
					end = end - 1;
				textView.DisplayTextLineContainingBufferPosition(end, 0, ViewRelativePosition.Bottom);
			}
		}
Exemple #16
0
		void EnsureSpanVisibleY(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options) {
			bool showStart = (options & EnsureSpanVisibleOptions.ShowStart) != 0;
			bool minimumScroll = (options & EnsureSpanVisibleOptions.MinimumScroll) != 0;
			bool alwaysCenter = (options & EnsureSpanVisibleOptions.AlwaysCenter) != 0;

			var bufferSpan = span.SnapshotSpan;
			var visibleSpan = VisibleSpan;
			bool spanIsInView = bufferSpan.Start >= visibleSpan.Start && bufferSpan.End <= visibleSpan.End;
			if (!spanIsInView) {
				ShowSpan(bufferSpan, options);
				alwaysCenter = true;
				visibleSpan = VisibleSpan;
				spanIsInView = bufferSpan.Start >= visibleSpan.Start && bufferSpan.End <= visibleSpan.End;
			}

			if (spanIsInView) {
				var lines = textView.TextViewLines.GetTextViewLinesIntersectingSpan(bufferSpan);
				Debug.Assert(lines.Count > 0);
				if (lines.Count == 0)
					return;
				var first = lines[0];
				var last = lines[lines.Count - 1];
				var firstSpan = first.ExtentIncludingLineBreak;
				var lastSpan = last.ExtentIncludingLineBreak;

				bool allLinesFullyVisible = first.VisibilityState == VisibilityState.FullyVisible && last.VisibilityState == VisibilityState.FullyVisible;

				if (alwaysCenter || (!allLinesFullyVisible && !minimumScroll)) {
					double height = last.Bottom - first.Top;
					double verticalDistance = (textView.ViewportHeight - height) / 2;
					textView.DisplayTextLineContainingBufferPosition(first.Start, verticalDistance, ViewRelativePosition.Top);
					return;
				}

				if (first.VisibilityState != VisibilityState.FullyVisible) {
					if (first != last || !minimumScroll || first.VisibilityState != VisibilityState.PartiallyVisible)
						textView.DisplayTextLineContainingBufferPosition(first.Start, 0, ViewRelativePosition.Top);
					else if (first.Bottom > textView.ViewportBottom)
						textView.DisplayTextLineContainingBufferPosition(first.Start, 0, ViewRelativePosition.Bottom);
					else
						textView.DisplayTextLineContainingBufferPosition(first.Start, 0, ViewRelativePosition.Top);
				}
				else if (last.VisibilityState != VisibilityState.FullyVisible)
					textView.DisplayTextLineContainingBufferPosition(last.Start, 0, ViewRelativePosition.Bottom);

				if (showStart) {
					var line = textView.TextViewLines.GetTextViewLineContainingBufferPosition(firstSpan.Start);
					if (line == null || line.VisibilityState != VisibilityState.FullyVisible)
						ShowSpan(bufferSpan, options);
				}
				else {
					var line = textView.TextViewLines.GetTextViewLineContainingBufferPosition(lastSpan.Start);
					if (line == null || line.VisibilityState != VisibilityState.FullyVisible)
						ShowSpan(bufferSpan, options);
				}
			}
		}
Exemple #17
0
 public void EnsureSpanVisible(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options)
 {
     throw new NotImplementedException();
 }
Exemple #18
0
        void EnsureSpanVisibleX(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options)
        {
            if ((textView.Options.WordWrapStyle() & WordWrapStyles.WordWrap) != 0)
            {
                return;
            }
            if (textView.ViewportWidth == 0)
            {
                return;
            }

            var lines = textView.TextViewLines.GetTextViewLinesIntersectingSpan(span.SnapshotSpan);

            if (lines.Count == 0)
            {
                return;
            }

            var ispan = span.Intersection(new VirtualSnapshotSpan(textView.TextViewLines.FormattedSpan));

            if (ispan == null)
            {
                return;
            }
            span = ispan.Value;

            double left = double.PositiveInfinity, right = double.NegativeInfinity;

            for (int i = 0; i < lines.Count; i++)
            {
                var line     = lines[i];
                var lineSpan = line.ExtentIncludingLineBreak.Intersection(span.SnapshotSpan);
                if (lineSpan == null)
                {
                    continue;
                }

                var startPoint = new VirtualSnapshotPoint(lineSpan.Value.Start);
                var endPoint   = new VirtualSnapshotPoint(lineSpan.Value.End);
                if (startPoint.Position == span.Start.Position)
                {
                    startPoint = span.Start;
                }
                if (endPoint.Position == span.End.Position)
                {
                    endPoint = span.End;
                }

                var startBounds = line.GetExtendedCharacterBounds(startPoint);
                var endBounds   = line.GetExtendedCharacterBounds(endPoint);

                if (left > startBounds.Left)
                {
                    left = startBounds.Left;
                }
                if (right < startBounds.Right)
                {
                    right = startBounds.Right;
                }
                if (left > endBounds.Left)
                {
                    left = endBounds.Left;
                }
                if (right < endBounds.Right)
                {
                    right = endBounds.Right;
                }
            }
            if (double.IsInfinity(left) || double.IsInfinity(right))
            {
                return;
            }
            Debug.Assert(left <= right);
            if (left > right)
            {
                right = left;
            }
            double width = right - left;

            double       availWidth = Math.Max(0, textView.ViewportWidth - width);
            double       extraScroll;
            const double EXTRA_WIDTH = 4;

            if (availWidth >= EXTRA_WIDTH)
            {
                extraScroll = EXTRA_WIDTH;
            }
            else
            {
                extraScroll = availWidth / 2;
            }

            if (textView.ViewportLeft <= right && right <= textView.ViewportRight)
            {
            }
            else if (right > textView.ViewportRight)
            {
                textView.ViewportLeft = right + extraScroll - textView.ViewportWidth;
            }
            else
            {
                var newLeft = left - extraScroll;
                if (newLeft + textView.ViewportWidth < right)
                {
                    newLeft = right - textView.ViewportWidth;
                }
                textView.ViewportLeft = newLeft;
            }
        }
Exemple #19
0
 public void EnsureSpanVisible(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options)
 {
 }
Exemple #20
0
		public void SelectAndMoveCaret(VirtualSnapshotPoint anchorPoint, VirtualSnapshotPoint activePoint, TextSelectionMode selectionMode, EnsureSpanVisibleOptions? scrollOptions) {
			anchorPoint = anchorPoint.TranslateTo(Snapshot);
			activePoint = activePoint.TranslateTo(Snapshot);
			if (anchorPoint == activePoint)
				Selection.Clear();
			else
				Selection.Select(anchorPoint, activePoint);
			Selection.Mode = selectionMode;
			activePoint = activePoint.TranslateTo(Snapshot);
			Caret.MoveTo(activePoint);
			if (scrollOptions == null)
				return;
			anchorPoint = anchorPoint.TranslateTo(Snapshot);
			activePoint = activePoint.TranslateTo(Snapshot);
			if (activePoint > anchorPoint)
				ViewScroller.EnsureSpanVisible(new SnapshotSpan(anchorPoint.Position, activePoint.Position), scrollOptions.Value & ~EnsureSpanVisibleOptions.ShowStart);
			else
				ViewScroller.EnsureSpanVisible(new SnapshotSpan(activePoint.Position, anchorPoint.Position), scrollOptions.Value | EnsureSpanVisibleOptions.ShowStart);
		}
Exemple #21
0
		void EnsureSpanVisibleX(VirtualSnapshotSpan span, EnsureSpanVisibleOptions options) {
			if ((textView.Options.WordWrapStyle() & WordWrapStyles.WordWrap) != 0)
				return;
			if (textView.ViewportWidth == 0)
				return;

			var lines = textView.TextViewLines.GetTextViewLinesIntersectingSpan(span.SnapshotSpan);
			if (lines.Count == 0)
				return;

			var ispan = span.Intersection(new VirtualSnapshotSpan(textView.TextViewLines.FormattedSpan));
			if (ispan == null)
				return;
			span = ispan.Value;

			double left = double.PositiveInfinity, right = double.NegativeInfinity;
			for (int i = 0; i < lines.Count; i++) {
				var line = lines[i];
				var lineSpan = line.ExtentIncludingLineBreak.Intersection(span.SnapshotSpan);
				if (lineSpan == null)
					continue;

				var startPoint = new VirtualSnapshotPoint(lineSpan.Value.Start);
				var endPoint = new VirtualSnapshotPoint(lineSpan.Value.End);
				if (startPoint.Position == span.Start.Position)
					startPoint = span.Start;
				if (endPoint.Position == span.End.Position)
					endPoint = span.End;

				var startBounds = line.GetExtendedCharacterBounds(startPoint);
				var endBounds = line.GetExtendedCharacterBounds(endPoint);

				if (left > startBounds.Left)
					left = startBounds.Left;
				if (right < startBounds.Right)
					right = startBounds.Right;
				if (left > endBounds.Left)
					left = endBounds.Left;
				if (right < endBounds.Right)
					right = endBounds.Right;

			}
			if (double.IsInfinity(left) || double.IsInfinity(right))
				return;
			Debug.Assert(left <= right);
			if (left > right)
				right = left;
			double width = right - left;

			double availWidth = Math.Max(0, textView.ViewportWidth - width);
			double extraScroll;
			const double EXTRA_WIDTH = 4;
			if (availWidth >= EXTRA_WIDTH)
				extraScroll = EXTRA_WIDTH;
			else
				extraScroll = availWidth / 2;

			if (textView.ViewportLeft <= right && right <= textView.ViewportRight) {
			}
			else if (right > textView.ViewportRight)
				textView.ViewportLeft = right + extraScroll - textView.ViewportWidth;
			else {
				var newLeft = left - extraScroll;
				if (newLeft + textView.ViewportWidth < right)
					newLeft = right - textView.ViewportWidth;
				textView.ViewportLeft = newLeft;
			}
		}
Exemple #22
0
		public void SelectAndMoveCaret(VirtualSnapshotPoint anchorPoint, VirtualSnapshotPoint activePoint, TextSelectionMode selectionMode, EnsureSpanVisibleOptions? scrollOptions) => EditorOperations.SelectAndMoveCaret(anchorPoint, activePoint, selectionMode, scrollOptions);