diff options
Diffstat (limited to 'Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Rendering/VisualLine.cs')
| -rw-r--r-- | Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Rendering/VisualLine.cs | 681 |
1 files changed, 681 insertions, 0 deletions
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Rendering/VisualLine.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Rendering/VisualLine.cs new file mode 100644 index 000000000..70727dd07 --- /dev/null +++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Rendering/VisualLine.cs @@ -0,0 +1,681 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) + +using System.Linq; +using System.Windows.Controls; +using System.Windows.Media; +using Tango.Scripting.Editors.Utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.Windows; +using System.Windows.Documents; +using System.Windows.Media.TextFormatting; +using Tango.Scripting.Editors.Document; + +namespace Tango.Scripting.Editors.Rendering +{ + /// <summary> + /// Represents a visual line in the document. + /// A visual line usually corresponds to one DocumentLine, but it can span multiple lines if + /// all but the first are collapsed. + /// </summary> + public sealed class VisualLine + { + enum LifetimePhase : byte + { + Generating, + Transforming, + Live, + Disposed + } + + TextView textView; + List<VisualLineElement> elements; + internal bool hasInlineObjects; + LifetimePhase phase; + + /// <summary> + /// Gets the document to which this VisualLine belongs. + /// </summary> + public TextDocument Document { get; private set; } + + /// <summary> + /// Gets the first document line displayed by this visual line. + /// </summary> + public DocumentLine FirstDocumentLine { get; private set; } + + /// <summary> + /// Gets the last document line displayed by this visual line. + /// </summary> + public DocumentLine LastDocumentLine { get; private set; } + + /// <summary> + /// Gets a read-only collection of line elements. + /// </summary> + public ReadOnlyCollection<VisualLineElement> Elements { get; private set; } + + ReadOnlyCollection<TextLine> textLines; + + /// <summary> + /// Gets a read-only collection of text lines. + /// </summary> + public ReadOnlyCollection<TextLine> TextLines { + get { + if (phase < LifetimePhase.Live) + throw new InvalidOperationException(); + return textLines; + } + } + + /// <summary> + /// Gets the start offset of the VisualLine inside the document. + /// This is equivalent to <c>FirstDocumentLine.Offset</c>. + /// </summary> + public int StartOffset { + get { + return FirstDocumentLine.Offset; + } + } + + /// <summary> + /// Length in visual line coordinates. + /// </summary> + public int VisualLength { get; private set; } + + /// <summary> + /// Length in visual line coordinates including the end of line marker, if TextEditorOptions.ShowEndOfLine is enabled. + /// </summary> + public int VisualLengthWithEndOfLineMarker { + get { + int length = VisualLength; + if (textView.Options.ShowEndOfLine && LastDocumentLine.NextLine != null) length++; + return length; + } + } + + /// <summary> + /// Gets the height of the visual line in device-independent pixels. + /// </summary> + public double Height { get; private set; } + + /// <summary> + /// Gets the Y position of the line. This is measured in device-independent pixels relative to the start of the document. + /// </summary> + public double VisualTop { get; internal set; } + + internal VisualLine(TextView textView, DocumentLine firstDocumentLine) + { + Debug.Assert(textView != null); + Debug.Assert(firstDocumentLine != null); + this.textView = textView; + this.Document = textView.Document; + this.FirstDocumentLine = firstDocumentLine; + } + + internal void ConstructVisualElements(ITextRunConstructionContext context, VisualLineElementGenerator[] generators) + { + Debug.Assert(phase == LifetimePhase.Generating); + foreach (VisualLineElementGenerator g in generators) { + g.StartGeneration(context); + } + elements = new List<VisualLineElement>(); + PerformVisualElementConstruction(generators); + foreach (VisualLineElementGenerator g in generators) { + g.FinishGeneration(); + } + + var globalTextRunProperties = context.GlobalTextRunProperties; + foreach (var element in elements) { + element.SetTextRunProperties(new VisualLineElementTextRunProperties(globalTextRunProperties)); + } + this.Elements = elements.AsReadOnly(); + CalculateOffsets(); + phase = LifetimePhase.Transforming; + } + + void PerformVisualElementConstruction(VisualLineElementGenerator[] generators) + { + TextDocument document = this.Document; + int offset = FirstDocumentLine.Offset; + int currentLineEnd = offset + FirstDocumentLine.Length; + LastDocumentLine = FirstDocumentLine; + int askInterestOffset = 0; // 0 or 1 + while (offset + askInterestOffset <= currentLineEnd) { + int textPieceEndOffset = currentLineEnd; + foreach (VisualLineElementGenerator g in generators) { + g.cachedInterest = g.GetFirstInterestedOffset(offset + askInterestOffset); + if (g.cachedInterest != -1) { + if (g.cachedInterest < offset) + throw new ArgumentOutOfRangeException(g.GetType().Name + ".GetFirstInterestedOffset", + g.cachedInterest, + "GetFirstInterestedOffset must not return an offset less than startOffset. Return -1 to signal no interest."); + if (g.cachedInterest < textPieceEndOffset) + textPieceEndOffset = g.cachedInterest; + } + } + Debug.Assert(textPieceEndOffset >= offset); + if (textPieceEndOffset > offset) { + int textPieceLength = textPieceEndOffset - offset; + elements.Add(new VisualLineText(this, textPieceLength)); + offset = textPieceEndOffset; + } + // If no elements constructed / only zero-length elements constructed: + // do not asking the generators again for the same location (would cause endless loop) + askInterestOffset = 1; + foreach (VisualLineElementGenerator g in generators) { + if (g.cachedInterest == offset) { + VisualLineElement element = g.ConstructElement(offset); + if (element != null) { + elements.Add(element); + if (element.DocumentLength > 0) { + // a non-zero-length element was constructed + askInterestOffset = 0; + offset += element.DocumentLength; + if (offset > currentLineEnd) { + DocumentLine newEndLine = document.GetLineByOffset(offset); + currentLineEnd = newEndLine.Offset + newEndLine.Length; + this.LastDocumentLine = newEndLine; + //if (currentLineEnd < offset) { + // throw new InvalidOperationException( + // "The VisualLineElementGenerator " + g.GetType().Name + + // " produced an element which ends within the line delimiter"); + //} + } + break; + } + } + } + } + } + } + + void CalculateOffsets() + { + int visualOffset = 0; + int textOffset = 0; + foreach (VisualLineElement element in elements) { + element.VisualColumn = visualOffset; + element.RelativeTextOffset = textOffset; + visualOffset += element.VisualLength; + textOffset += element.DocumentLength; + } + VisualLength = visualOffset; + //Debug.Assert(textOffset == LastDocumentLine.EndOffset - FirstDocumentLine.Offset); + } + + internal void RunTransformers(ITextRunConstructionContext context, IVisualLineTransformer[] transformers) + { + Debug.Assert(phase == LifetimePhase.Transforming); + foreach (IVisualLineTransformer transformer in transformers) { + transformer.Transform(context, elements); + } + // For some strange reason, WPF requires that either all or none of the typography properties are set. + if (elements.Any(e => e.TextRunProperties.TypographyProperties != null)) { + // Fix typographic properties + foreach (VisualLineElement element in elements) { + if (element.TextRunProperties.TypographyProperties == null) { + element.TextRunProperties.SetTypographyProperties(new DefaultTextRunTypographyProperties()); + } + } + } + phase = LifetimePhase.Live; + } + + /// <summary> + /// Replaces the single element at <paramref name="elementIndex"/> with the specified elements. + /// The replacement operation must preserve the document length, but may change the visual length. + /// </summary> + /// <remarks> + /// This method may only be called by line transformers. + /// </remarks> + public void ReplaceElement(int elementIndex, params VisualLineElement[] newElements) + { + ReplaceElement(elementIndex, 1, newElements); + } + + /// <summary> + /// Replaces <paramref name="count"/> elements starting at <paramref name="elementIndex"/> with the specified elements. + /// The replacement operation must preserve the document length, but may change the visual length. + /// </summary> + /// <remarks> + /// This method may only be called by line transformers. + /// </remarks> + public void ReplaceElement(int elementIndex, int count, params VisualLineElement[] newElements) + { + if (phase != LifetimePhase.Transforming) + throw new InvalidOperationException("This method may only be called by line transformers."); + int oldDocumentLength = 0; + for (int i = elementIndex; i < elementIndex + count; i++) { + oldDocumentLength += elements[i].DocumentLength; + } + int newDocumentLength = 0; + foreach (var newElement in newElements) { + newDocumentLength += newElement.DocumentLength; + } + if (oldDocumentLength != newDocumentLength) + throw new InvalidOperationException("Old elements have document length " + oldDocumentLength + ", but new elements have length " + newDocumentLength); + elements.RemoveRange(elementIndex, count); + elements.InsertRange(elementIndex, newElements); + CalculateOffsets(); + } + + internal void SetTextLines(List<TextLine> textLines) + { + this.textLines = textLines.AsReadOnly(); + Height = 0; + foreach (TextLine line in textLines) + Height += line.Height; + } + + /// <summary> + /// Gets the visual column from a document offset relative to the first line start. + /// </summary> + public int GetVisualColumn(int relativeTextOffset) + { + ThrowUtil.CheckNotNegative(relativeTextOffset, "relativeTextOffset"); + foreach (VisualLineElement element in elements) { + if (element.RelativeTextOffset <= relativeTextOffset + && element.RelativeTextOffset + element.DocumentLength >= relativeTextOffset) + { + return element.GetVisualColumn(relativeTextOffset); + } + } + return VisualLength; + } + + /// <summary> + /// Gets the document offset (relative to the first line start) from a visual column. + /// </summary> + public int GetRelativeOffset(int visualColumn) + { + ThrowUtil.CheckNotNegative(visualColumn, "visualColumn"); + int documentLength = 0; + foreach (VisualLineElement element in elements) { + if (element.VisualColumn <= visualColumn + && element.VisualColumn + element.VisualLength > visualColumn) + { + return element.GetRelativeOffset(visualColumn); + } + documentLength += element.DocumentLength; + } + return documentLength; + } + + /// <summary> + /// Gets the text line containing the specified visual column. + /// </summary> + public TextLine GetTextLine(int visualColumn) + { + if (visualColumn < 0) + throw new ArgumentOutOfRangeException("visualColumn"); + if (visualColumn >= VisualLengthWithEndOfLineMarker) + return TextLines[TextLines.Count - 1]; + foreach (TextLine line in TextLines) { + if (visualColumn < line.Length) + return line; + else + visualColumn -= line.Length; + } + throw new InvalidOperationException("Shouldn't happen (VisualLength incorrect?)"); + } + + /// <summary> + /// Gets the visual top from the specified text line. + /// </summary> + /// <returns>Distance in device-independent pixels + /// from the top of the document to the top of the specified text line.</returns> + public double GetTextLineVisualYPosition(TextLine textLine, VisualYPosition yPositionMode) + { + if (textLine == null) + throw new ArgumentNullException("textLine"); + double pos = VisualTop; + foreach (TextLine tl in TextLines) { + if (tl == textLine) { + switch (yPositionMode) { + case VisualYPosition.LineTop: + return pos; + case VisualYPosition.LineMiddle: + return pos + tl.Height / 2; + case VisualYPosition.LineBottom: + return pos + tl.Height; + case VisualYPosition.TextTop: + return pos + tl.Baseline - textView.DefaultBaseline; + case VisualYPosition.TextBottom: + return pos + tl.Baseline - textView.DefaultBaseline + textView.DefaultLineHeight; + case VisualYPosition.TextMiddle: + return pos + tl.Baseline - textView.DefaultBaseline + textView.DefaultLineHeight / 2; + case VisualYPosition.Baseline: + return pos + tl.Baseline; + default: + throw new ArgumentException("Invalid yPositionMode:" + yPositionMode); + } + } else { + pos += tl.Height; + } + } + throw new ArgumentException("textLine is not a line in this VisualLine"); + } + + /// <summary> + /// Gets the start visual column from the specified text line. + /// </summary> + public int GetTextLineVisualStartColumn(TextLine textLine) + { + if (!TextLines.Contains(textLine)) + throw new ArgumentException("textLine is not a line in this VisualLine"); + int col = 0; + foreach (TextLine tl in TextLines) { + if (tl == textLine) + break; + else + col += tl.Length; + } + return col; + } + + /// <summary> + /// Gets a TextLine by the visual position. + /// </summary> + public TextLine GetTextLineByVisualYPosition(double visualTop) + { + const double epsilon = 0.0001; + double pos = this.VisualTop; + foreach (TextLine tl in TextLines) { + pos += tl.Height; + if (visualTop + epsilon < pos) + return tl; + } + return TextLines[TextLines.Count - 1]; + } + + /// <summary> + /// Gets the visual position from the specified visualColumn. + /// </summary> + /// <returns>Position in device-independent pixels + /// relative to the top left of the document.</returns> + public Point GetVisualPosition(int visualColumn, VisualYPosition yPositionMode) + { + TextLine textLine = GetTextLine(visualColumn); + double xPos = GetTextLineVisualXPosition(textLine, visualColumn); + double yPos = GetTextLineVisualYPosition(textLine, yPositionMode); + return new Point(xPos, yPos); + } + + /// <summary> + /// Gets the distance to the left border of the text area of the specified visual column. + /// The visual column must belong to the specified text line. + /// </summary> + public double GetTextLineVisualXPosition(TextLine textLine, int visualColumn) + { + if (textLine == null) + throw new ArgumentNullException("textLine"); + double xPos = textLine.GetDistanceFromCharacterHit( + new CharacterHit(Math.Min(visualColumn, VisualLengthWithEndOfLineMarker), 0)); + if (visualColumn > VisualLengthWithEndOfLineMarker) { + xPos += (visualColumn - VisualLengthWithEndOfLineMarker) * textView.WideSpaceWidth; + } + return xPos; + } + + /// <summary> + /// Gets the visual column from a document position (relative to top left of the document). + /// If the user clicks between two visual columns, rounds to the nearest column. + /// </summary> + public int GetVisualColumn(Point point) + { + return GetVisualColumn(point, textView.Options.EnableVirtualSpace); + } + + /// <summary> + /// Gets the visual column from a document position (relative to top left of the document). + /// If the user clicks between two visual columns, rounds to the nearest column. + /// </summary> + public int GetVisualColumn(Point point, bool allowVirtualSpace) + { + return GetVisualColumn(GetTextLineByVisualYPosition(point.Y), point.X, allowVirtualSpace); + } + + /// <summary> + /// Gets the visual column from a document position (relative to top left of the document). + /// If the user clicks between two visual columns, rounds to the nearest column. + /// </summary> + public int GetVisualColumn(TextLine textLine, double xPos, bool allowVirtualSpace) + { + if (xPos > textLine.WidthIncludingTrailingWhitespace) { + if (allowVirtualSpace && textLine == TextLines[TextLines.Count - 1]) { + int virtualX = (int)Math.Round((xPos - textLine.WidthIncludingTrailingWhitespace) / textView.WideSpaceWidth); + return VisualLengthWithEndOfLineMarker + virtualX; + } + } + CharacterHit ch = textLine.GetCharacterHitFromDistance(xPos); + return ch.FirstCharacterIndex + ch.TrailingLength; + } + + /// <summary> + /// Validates the visual column and returns the correct one. + /// </summary> + public int ValidateVisualColumn(TextViewPosition position, bool allowVirtualSpace) + { + return ValidateVisualColumn(Document.GetOffset(position.Location), position.VisualColumn, allowVirtualSpace); + } + + /// <summary> + /// Validates the visual column and returns the correct one. + /// </summary> + public int ValidateVisualColumn(int offset, int visualColumn, bool allowVirtualSpace) + { + int firstDocumentLineOffset = this.FirstDocumentLine.Offset; + if (visualColumn < 0) { + return GetVisualColumn(offset - firstDocumentLineOffset); + } else { + int offsetFromVisualColumn = GetRelativeOffset(visualColumn); + offsetFromVisualColumn += firstDocumentLineOffset; + if (offsetFromVisualColumn != offset) { + return GetVisualColumn(offset - firstDocumentLineOffset); + } else { + if (visualColumn > VisualLength && !allowVirtualSpace) { + return VisualLength; + } + } + } + return visualColumn; + } + + /// <summary> + /// Gets the visual column from a document position (relative to top left of the document). + /// If the user clicks between two visual columns, returns the first of those columns. + /// </summary> + public int GetVisualColumnFloor(Point point) + { + return GetVisualColumnFloor(point, textView.Options.EnableVirtualSpace); + } + + /// <summary> + /// Gets the visual column from a document position (relative to top left of the document). + /// If the user clicks between two visual columns, returns the first of those columns. + /// </summary> + public int GetVisualColumnFloor(Point point, bool allowVirtualSpace) + { + TextLine textLine = GetTextLineByVisualYPosition(point.Y); + if (point.X > textLine.WidthIncludingTrailingWhitespace) { + if (allowVirtualSpace && textLine == TextLines[TextLines.Count - 1]) { + // clicking virtual space in the last line + int virtualX = (int)((point.X - textLine.WidthIncludingTrailingWhitespace) / textView.WideSpaceWidth); + return VisualLengthWithEndOfLineMarker + virtualX; + } else { + // GetCharacterHitFromDistance returns a hit with FirstCharacterIndex=last character in line + // and TrailingLength=1 when clicking behind the line, so the floor function needs to handle this case + // specially and return the line's end column instead. + return GetTextLineVisualStartColumn(textLine) + textLine.Length; + } + } + CharacterHit ch = textLine.GetCharacterHitFromDistance(point.X); + return ch.FirstCharacterIndex; + } + + /// <summary> + /// Gets whether the visual line was disposed. + /// </summary> + public bool IsDisposed { + get { return phase == LifetimePhase.Disposed; } + } + + internal void Dispose() + { + if (phase == LifetimePhase.Disposed) + return; + Debug.Assert(phase == LifetimePhase.Live); + phase = LifetimePhase.Disposed; + foreach (TextLine textLine in TextLines) { + textLine.Dispose(); + } + } + + /// <summary> + /// Gets the next possible caret position after visualColumn, or -1 if there is no caret position. + /// </summary> + public int GetNextCaretPosition(int visualColumn, LogicalDirection direction, CaretPositioningMode mode, bool allowVirtualSpace) + { + if (!HasStopsInVirtualSpace(mode)) + allowVirtualSpace = false; + + if (elements.Count == 0) { + // special handling for empty visual lines: + if (allowVirtualSpace) { + if (direction == LogicalDirection.Forward) + return Math.Max(0, visualColumn + 1); + else if (visualColumn > 0) + return visualColumn - 1; + else + return -1; + } else { + // even though we don't have any elements, + // there's a single caret stop at visualColumn 0 + if (visualColumn < 0 && direction == LogicalDirection.Forward) + return 0; + else if (visualColumn > 0 && direction == LogicalDirection.Backward) + return 0; + else + return -1; + } + } + + int i; + if (direction == LogicalDirection.Backward) { + // Search Backwards: + // If the last element doesn't handle line borders, return the line end as caret stop + + if (visualColumn > this.VisualLength && !elements[elements.Count-1].HandlesLineBorders && HasImplicitStopAtLineEnd(mode)) { + if (allowVirtualSpace) + return visualColumn - 1; + else + return this.VisualLength; + } + // skip elements that start after or at visualColumn + for (i = elements.Count - 1; i >= 0; i--) { + if (elements[i].VisualColumn < visualColumn) + break; + } + // search last element that has a caret stop + for (; i >= 0; i--) { + int pos = elements[i].GetNextCaretPosition( + Math.Min(visualColumn, elements[i].VisualColumn + elements[i].VisualLength + 1), + direction, mode); + if (pos >= 0) + return pos; + } + // If we've found nothing, and the first element doesn't handle line borders, + // return the line start as normal caret stop. + if (visualColumn > 0 && !elements[0].HandlesLineBorders && HasImplicitStopAtLineStart(mode)) + return 0; + } else { + // Search Forwards: + // If the first element doesn't handle line borders, return the line start as caret stop + if (visualColumn < 0 && !elements[0].HandlesLineBorders && HasImplicitStopAtLineStart(mode)) + return 0; + // skip elements that end before or at visualColumn + for (i = 0; i < elements.Count; i++) { + if (elements[i].VisualColumn + elements[i].VisualLength > visualColumn) + break; + } + // search first element that has a caret stop + for (; i < elements.Count; i++) { + int pos = elements[i].GetNextCaretPosition( + Math.Max(visualColumn, elements[i].VisualColumn - 1), + direction, mode); + if (pos >= 0) + return pos; + } + // if we've found nothing, and the last element doesn't handle line borders, + // return the line end as caret stop + if ((allowVirtualSpace || !elements[elements.Count-1].HandlesLineBorders) && HasImplicitStopAtLineEnd(mode)) { + if (visualColumn < this.VisualLength) + return this.VisualLength; + else if (allowVirtualSpace) + return visualColumn + 1; + } + } + // we've found nothing, return -1 and let the caret search continue in the next line + return -1; + } + + static bool HasStopsInVirtualSpace(CaretPositioningMode mode) + { + return mode == CaretPositioningMode.Normal; + } + + static bool HasImplicitStopAtLineStart(CaretPositioningMode mode) + { + return mode == CaretPositioningMode.Normal; + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "mode", + Justification = "make method consistent with HasImplicitStopAtLineStart; might depend on mode in the future")] + static bool HasImplicitStopAtLineEnd(CaretPositioningMode mode) + { + return true; + } + + VisualLineDrawingVisual visual; + + internal VisualLineDrawingVisual Render() + { + Debug.Assert(phase == LifetimePhase.Live); + if (visual == null) + visual = new VisualLineDrawingVisual(this); + return visual; + } + } + + sealed class VisualLineDrawingVisual : DrawingVisual + { + public readonly VisualLine VisualLine; + public readonly double Height; + internal bool IsAdded; + + public VisualLineDrawingVisual(VisualLine visualLine) + { + this.VisualLine = visualLine; + var drawingContext = RenderOpen(); + double pos = 0; + foreach (TextLine textLine in visualLine.TextLines) { + textLine.Draw(drawingContext, new Point(0, pos), InvertAxes.None); + pos += textLine.Height; + } + this.Height = pos; + drawingContext.Close(); + } + + protected override GeometryHitTestResult HitTestCore(GeometryHitTestParameters hitTestParameters) + { + return null; + } + + protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters) + { + return null; + } + } +} |