public void Draw(TextView textView, DrawingContext drawingContext)
{
if (host == null)
{
return;
}
var snapshot = isParentSnapshot ? host.SnapshotParent : host.Snapshot;
if (snapshot == null)
{
return;
}
foreach (var v in textView.VisualLines)
{
var rc = BackgroundGeometryBuilder.GetRectsFromVisualSegment(textView, v, 0, 1000).First();
var linenum = v.FirstDocumentLine.LineNumber - 1;
if (linenum >= snapshot.FileDetails.Count)
{
continue;
}
drawingContext.DrawRectangle(GetLineBackgroundBrush(snapshot, linenum), pen, new Rect(0, rc.Top, textView.ActualWidth, rc.Height));
}
}
private void DrawSegment(DiffSegment segment, TextView textView, DrawingContext drawingContext)
{
BackgroundGeometryBuilder geoBuilder = new BackgroundGeometryBuilder
{
AlignToWholePixels = true,
BorderThickness = 0,
CornerRadius = 3,
};
Brush markerBrush;
switch (segment.type)
{
case DiffItem.DiffType.Deleted:
markerBrush = deletedBrush;
geoBuilder.AddSegment(textView, segment);
break;
case DiffItem.DiffType.Inserted:
markerBrush = addedBrush;
geoBuilder.AddSegment(textView, segment);
break;
default:
markerBrush = null;
break;
}
Geometry geometry = geoBuilder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(markerBrush, null, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (this.openBracketOffset == null || this.closeBracketOffset == null)
{
return;
}
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
builder.CornerRadius = 1;
builder.AlignToMiddleOfPixels = true;
builder.AddSegment(textView, new TextSegment()
{
StartOffset = openBracketOffset, Length = 1
});
builder.CloseFigure(); // prevent connecting the two segments
builder.AddSegment(textView, new TextSegment()
{
StartOffset = closeBracketOffset, Length = 1
});
Geometry geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, borderPen, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
textView.EnsureVisualLines();
var color = new SolidColorBrush(ConfigHost.Coloring.BreakPoint.TextHighlightColor);
color.Freeze();
var invalidBps = new List <DataContext.BreakpointsPaneUtil.Breakpoint>();
foreach (var bp in this.SolutionFileRef.BreakPoints)
{
if (bp.Line < 0)
{
Logger.Log(NLog.LogLevel.Warn, $"Removed invalid breakpoint in file '{this.SolutionFileRef.FileName}'.");
invalidBps.Add(bp);
continue;
}
var line = this.Document.GetLineByNumber(bp.Line);
var segment = new TextSegment {
StartOffset = line.Offset, EndOffset = line.EndOffset
};
foreach (var rect in BackgroundGeometryBuilder.GetRectsForSegment(textView, segment))
{
drawingContext.DrawRectangle(color, null, new Rect(rect.Location, new Size(textView.ActualWidth, rect.Height)));
}
}
foreach (var bp in invalidBps)
{
this.SolutionFileRef.BreakPoints.Remove(bp);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (result == null)
{
return;
}
var builder = new BackgroundGeometryBuilder
{
CornerRadius = 1,
AlignToWholePixels = true,
BorderThickness = 0.0
};
builder.AddSegment(textView, new TextSegment()
{
StartOffset = result.OpeningBracketOffset, Length = result.OpeningBracketLength
});
builder.CloseFigure();
builder.AddSegment(textView, new TextSegment()
{
StartOffset = result.ClosingBracketOffset, Length = result.ClosingBracketLength
});
var geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, null, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (_editor.Document == null || _offsetsToMark.Count == 0)
{
return;
}
textView.EnsureVisualLines();
foreach (var mark in _offsetsToMark)
{
foreach (Rect r in BackgroundGeometryBuilder.GetRectsForSegment(
textView, new TextSegment {
StartOffset = mark.Offset, Length = mark.Length
}))
{
drawingContext.DrawRoundedRectangle(
mark.Brush,
null,
new Rect(r.Location, r.Size),
3, 3
);
}
}
//http://danielgrunwald.de/coding/AvalonEdit/rendering.php
//http://stackoverflow.com/questions/5072761/avalonedit-highlight-current-line-even-when-not-focused
//DocumentLine currentLine = _editor.Document.GetLineByOffset((int)_offsetToMark);
//foreach (Rect rect in BackgroundGeometryBuilder.GetRectsForSegment(textView, currentLine))
//{
// drawingContext.DrawRectangle(
// new SolidColorBrush(Color.FromArgb(0x40, 0, 0, 0xFF)), null,
// new Rect(rect.Location, new Size(textView.ActualWidth - 32, rect.Height)));
//}
}
/// <summary>
/// Draw the background line highlighting of the current line.
/// </summary>
/// <param name="textView"></param>
/// <param name="drawingContext"></param>
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (this._Editor == null)
{
return;
}
if (this._Editor.Document == null)
{
return;
}
if (_Editor.EditorCurrentLineBorderThickness == 0 && _Editor.EditorCurrentLineBackground == null)
{
return;
}
Pen borderPen = null;
if (_Editor.EditorCurrentLineBorder != null)
{
borderPen = new Pen(_Editor.EditorCurrentLineBorder, _Editor.EditorCurrentLineBorderThickness);
borderPen.Freeze();
}
textView.EnsureVisualLines();
var currentLine = _Editor.Document.GetLineByOffset(_Editor.CaretOffset);
foreach (var rect in BackgroundGeometryBuilder.GetRectsForSegment(textView, currentLine))
{
drawingContext.DrawRectangle(_Editor.EditorCurrentLineBackground, borderPen,
new Rect(rect.Location, new Size(textView.ActualWidth, rect.Height)));
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (_textEditor.SelectionLength == 0 && _textEditor.CaretOffset != -1 &&
_textEditor.CaretOffset <= textView.Document.TextLength)
{
var currentLine = textView.Document.GetLocation(_textEditor.CaretOffset).Line;
var visualLine = textView.GetVisualLine(currentLine);
if (visualLine == null)
{
return;
}
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
var linePosY = visualLine.VisualTop - textView.ScrollOffset.Y;
var lineBottom = linePosY + visualLine.Height;
Size pixelSize = PixelSnapHelpers.GetPixelSize(textView);
double x = PixelSnapHelpers.PixelAlign(0, pixelSize.Width);
double y = PixelSnapHelpers.PixelAlign(linePosY, pixelSize.Height);
var x2 = PixelSnapHelpers.PixelAlign(textView.Bounds.Width, pixelSize.Width);
var y2 = PixelSnapHelpers.PixelAlign(lineBottom, pixelSize.Height);
builder.AddRectangle(textView, new Rect(new Point(x, y), new Point(x2, y2)));
Geometry geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(BackgroundBrush, BorderPen, geometry);
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
_owner = textView;
if (textView.VisualLinesValid && textView.Document != null)
{
if (_line > 0 && _line < textView.Document.LineCount)
{
var currentLine = textView.Document.GetLineByNumber(_line);
var segment = new TextSegment();
segment.StartOffset = currentLine.Offset;
segment.EndOffset = currentLine.EndOffset;
if (_startColumn != -1 && _endColumn != -1)
{
segment.StartOffset = textView.Document.GetOffset(_line, _startColumn);
segment.EndOffset = textView.Document.GetOffset(_line, _endColumn);
}
else
{
_startColumn = textView.Document.GetLocation(segment.StartOffset).Column;
_endColumn = textView.Document.GetLocation(segment.EndOffset).Column;
}
var rects = BackgroundGeometryBuilder.GetRectsForSegment(textView, segment);
foreach (var rect in rects)
{
var drawRect = new Rect(rect.TopLeft.X - 1, rect.TopLeft.Y - 1, rect.Width + 2, rect.Height + 2);
drawingContext.FillRectangle(selectedLineBg, drawRect);
}
}
}
}
void IBackgroundRenderer.Draw(TextView textView, DrawingContext drawingContext)
{
if (markers == null || !textView.VisualLinesValid)
{
return;
}
var visualLines = textView.VisualLines;
if (visualLines.Count == 0)
{
return;
}
var viewStart = visualLines.First().FirstDocumentLine.Offset;
var viewEnd = visualLines.Last().LastDocumentLine.EndOffset;
foreach (var marker in markers.FindOverlappingSegments(viewStart, viewEnd - viewStart))
{
if (marker.BackgroundColor != null)
{
var geoBuilder = new BackgroundGeometryBuilder {
AlignToWholePixels = true, CornerRadius = 3
};
geoBuilder.AddSegment(textView, marker);
var geometry = geoBuilder.CreateGeometry();
if (geometry != null)
{
var color = marker.BackgroundColor.Value;
var brush = new SolidColorBrush(color);
brush.Freeze();
drawingContext.DrawGeometry(brush, null, geometry);
}
}
foreach (var r in BackgroundGeometryBuilder.GetRectsForSegment(textView, marker))
{
var startPoint = r.BottomLeft;
var endPoint = r.BottomRight;
var usedPen = new Pen(new SolidColorBrush(marker.MarkerColor), 1);
usedPen.Freeze();
const double offset = 2.5;
var count = Math.Max((int)((endPoint.X - startPoint.X) / offset) + 1, 4);
var geometry = new StreamGeometry();
using (var ctx = geometry.Open()) {
ctx.BeginFigure(startPoint, false, false);
ctx.PolyLineTo(CreatePoints(startPoint, endPoint, offset, count).ToArray(), true, false);
}
geometry.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, usedPen, geometry);
break;
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (result.HasValue)
{
var match = result.Value;
var builder = new BackgroundGeometryBuilder
{
CornerRadius = 1,
AlignToMiddleOfPixels = true
};
builder.AddSegment(textView, new TextSegment()
{
StartOffset = match.LeftSpan.Start, Length = match.LeftSpan.Length
});
builder.CloseFigure(); // prevent connecting the two segments
builder.AddSegment(textView, new TextSegment()
{
StartOffset = match.RightSpan.Start, Length = match.RightSpan.Length
});
Geometry geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, borderPen, geometry);
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
foreach (TextSegment current in this.SearchHitsSegments)
{
foreach (Rect current2 in BackgroundGeometryBuilder.GetRectsForSegment(textView, current))
{
Point bottomLeft = current2.BottomLeft;
Point bottomRight = current2.BottomRight;
Pen pen = new Pen(new SolidColorBrush(Colors.OrangeRed), 1);
pen.Freeze();
double num = 2.5;
int count = System.Math.Max((int)((bottomRight.X - bottomLeft.X) / num) + 1, 4);
StreamGeometry streamGeometry = new StreamGeometry();
using (StreamGeometryContext streamGeometryContext = streamGeometry.Open())
{
streamGeometryContext.BeginFigure(bottomLeft, true, true);
streamGeometryContext.LineTo(current2.TopLeft, true, false);
streamGeometryContext.LineTo(current2.TopRight, true, false);
streamGeometryContext.LineTo(current2.BottomRight, true, false);
}
streamGeometry.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, pen, streamGeometry);
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (BraceMatchingResult == null)
{
return;
}
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
builder.CornerRadius = 1;
builder.AlignToWholePixels = true;
builder.AddSegment(textView, new TextSegment()
{
StartOffset = BraceMatchingResult.Value.LeftSpan.Start, Length = BraceMatchingResult.Value.LeftSpan.Length
});
builder.CloseFigure(); // prevent connecting the two segments
builder.AddSegment(textView, new TextSegment()
{
StartOffset = BraceMatchingResult.Value.RightSpan.Start, Length = BraceMatchingResult.Value.RightSpan.Length
});
Geometry geometry = builder.CreateGeometry();
drawingContext.DrawGeometry(_backgroundBrush, _borderPen, geometry);
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (this.result == null)
{
return;
}
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
builder.CornerRadius = 1;
builder.AlignToMiddleOfPixels = true;
builder.AddSegment(textView, new TextSegment()
{
StartOffset = result.OpeningBracketOffset, Length = result.OpeningBracketLength
});
builder.CloseFigure(); // prevent connecting the two segments
builder.AddSegment(textView, new TextSegment()
{
StartOffset = result.ClosingBracketOffset, Length = result.ClosingBracketLength
});
Geometry geometry = builder.CreateGeometry();
if (borderPen == null)
{
this.UpdateColors(DefaultBackground, DefaultBackground);
}
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, borderPen, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (!Enabled)
{
return;
}
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
builder.CornerRadius = 1;
builder.AlignToWholePixels = true;
builder.AddSegment(textView, new TextSegment()
{
StartOffset = Begin, Length = 1
});
builder.CloseFigure();
builder.AddSegment(textView, new TextSegment()
{
StartOffset = End, Length = 1
});
Geometry geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, borderPen, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (this.FileFolderRef == null)
{
return;
}
textView.EnsureVisualLines();
var color = new SolidColorBrush(ConfigHost.Coloring.BreakPoint.TextHighlightColor);
color.Freeze();
foreach (var bp in Workspace.Instance.BreakpointManager[this.FileFolderRef])
{
if (!bp.IsEnabled)
{
continue;
}
if (bp.Line >= this.Document.LineCount)
{
Workspace.Instance.BreakpointManager.RemoveBreakpoint(bp);
continue;
}
var line = this.Document.GetLineByNumber(bp.Line);
var segment = new TextSegment {
StartOffset = line.Offset, EndOffset = line.EndOffset
};
foreach (var rect in BackgroundGeometryBuilder.GetRectsForSegment(textView, segment))
{
drawingContext.DrawRectangle(color, null, new Rect(rect.Location, new Size(textView.ActualWidth, rect.Height)));
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (result == null)
{
return;
}
var builder = new BackgroundGeometryBuilder();
builder.AlignToWholePixels = true;
builder.AddSegment(textView, new TextSegment {
StartOffset = result.OpeningOffset, Length = 1
});
builder.CloseFigure(); // prevent connecting the two segments
builder.AddSegment(textView, new TextSegment {
StartOffset = result.ClosingOffset, Length = 1
});
var geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, borderPen, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
var s = Element.Segment;
if (s != null)
{
var geoBuilder = new BackgroundGeometryBuilder
{
AlignToWholePixels = true,
BorderThickness = ActiveBorderPen?.Thickness ?? 0
};
if (Layer == KnownLayer.Background)
{
geoBuilder.AddSegment(textView, s);
drawingContext.DrawGeometry(BackgroundBrush, null, geoBuilder.CreateGeometry());
}
else
{
// draw foreground only if active
if (Element._isCaretInside)
{
geoBuilder.AddSegment(textView, s);
foreach (var boundElement in Element._context.ActiveElements.OfType <BoundActiveElement>())
{
if (boundElement.TargetElement == Element)
{
geoBuilder.AddSegment(textView, boundElement.Segment);
geoBuilder.CloseFigure();
}
}
drawingContext.DrawGeometry(null, ActiveBorderPen, geoBuilder.CreateGeometry());
}
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (currentReferences == null)
{
var start = textView.VisualLines.First().FirstDocumentLine.LineNumber;
var end = textView.VisualLines.Last().LastDocumentLine.LineNumber;
currentReferences = new List <ISegment>();
FindCurrentReferences(start, end);
}
if (currentReferences.Count == 0)
{
return;
}
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
builder.CornerRadius = cornerRadius;
builder.AlignToMiddleOfPixels = true;
foreach (var reference in this.currentReferences)
{
builder.AddSegment(textView, new TextSegment()
{
StartOffset = reference.Offset,
Length = reference.Length
});
builder.CloseFigure();
}
Geometry geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, borderPen, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (_editor.Document == null || CurrentCodeSectionManager == null || CurrentCodeSectionManager.CompilerErrorCollection == null)
{
return;
}
textView.EnsureVisualLines();
for (int i = 0; i < CurrentCodeSectionManager.CompilerErrorCollection.Count; ++i)
{
var error = CurrentCodeSectionManager.CompilerErrorCollection[i];
int lineNumber = error.Line - CurrentCodeSectionStartLine;
if (lineNumber > 0 && lineNumber < _editor.LineCount)
{
var line = _editor.Document.GetLineByNumber(lineNumber);
foreach (var rect in BackgroundGeometryBuilder.GetRectsForSegment(textView, line))
{
var rect2 = new Rect(rect.Location, new Size(textView.ActualWidth, rect.Height));
if (rect2.Height > 1 && rect2.Width > 1)
{
drawingContext.DrawRoundedRectangle(new SolidColorBrush(Color.FromArgb(0x20, 0xff, 0, 0)), new Pen(new SolidColorBrush(Color.FromArgb(0xa0, 0xff, 0, 0)), 1), rect2, 3, 3);
}
var column = error.Column - CurrentCodeSectionManager.GetSectionIndendationSize(CurrentCodeSectionId);
DrawColumnIndicator(drawingContext, new Point(rect2.Left + column * 7 + 3, rect2.Top - 1));
}
}
}
}
public void Draw(TextView textview, DrawingContext drawingContext)
{
if (_result != null)
{
var backgroundGeometryBuilder = new BackgroundGeometryBuilder
{
CornerRadius = 1.0,
AlignToWholePixels = true
// AlignToMiddleOfPixels = true
};
backgroundGeometryBuilder.AddSegment(textview, new TextSegment
{
StartOffset = _result.OpeningBracketOffset,
Length = _result.OpeningBracketLength
});
backgroundGeometryBuilder.CloseFigure();
backgroundGeometryBuilder.AddSegment(textview, new TextSegment
{
StartOffset = _result.ClosingBracketOffset,
Length = _result.ClosingBracketLength
});
var geometry = backgroundGeometryBuilder.CreateGeometry();
if (_borderPen == null)
{
UpdateColors(DefaultBackground, DefaultBackground);
}
if (geometry != null)
{
drawingContext.DrawGeometry(_backgroundBrush, _borderPen, geometry);
}
}
}
public void Draw(ICSharpCode.AvalonEdit.Rendering.TextView textView, DrawingContext drawingContext)
{
if (this.result == null)
{
return;
}
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
builder.CornerRadius = 1;
builder.AddSegment(textView, new TextSegment()
{
StartOffset = result.OpeningBracketOffset, Length = result.OpeningBracketLength
});
builder.CloseFigure(); // prevent connecting the two segments
builder.AddSegment(textView, new TextSegment()
{
StartOffset = result.ClosingBracketOffset, Length = result.ClosingBracketLength
});
Geometry geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, borderPen, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
foreach (var v in textView.VisualLines)
{
var rc = BackgroundGeometryBuilder.GetRectsFromVisualSegment(textView, v, 0, 1000).First();
int offset = v.FirstDocumentLine.Offset;
int length = v.FirstDocumentLine.Length;
var text = this.host.Text.Substring(offset, length);
Brush brush = null;
if (text.StartsWith("+"))
{
brush = addedBackground;
}
else if (text.StartsWith("-"))
{
brush = removedBackground;
}
else if (text.StartsWith("@"))
{
brush = headerBackground;
}
if (brush == null)
{
continue;
}
drawingContext.DrawRectangle(brush, pen,
new Rect(0, rc.Top, textView.ActualWidth, rc.Height));
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (_result == null)
{
return;
}
var builder = new BackgroundGeometryBuilder();
builder.CornerRadius = 1;
builder.AlignToMiddleOfPixels = true;
builder.AddSegment(textView, new TextSegment()
{
StartOffset = _result.OpeningBracketOffset, Length = _result.OpeningBracketLength
});
builder.CloseFigure();
builder.AddSegment(textView, new TextSegment()
{
StartOffset = _result.ClosingBracketOffset, Length = _result.ClosingBracketLength
});
var geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(_backgroundBrush, _borderPen, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (_editor?.LinesHit == null ||
!_editor.ShowLinesHit)
{
return;
}
foreach (var v in textView.VisualLines)
{
var rc = BackgroundGeometryBuilder.GetRectsFromVisualSegment(textView, v, 0, 1000).First();
int linenum = v.FirstDocumentLine.LineNumber;
bool hit;
if (_editor.LinesHit.TryGetValue(linenum, out hit))
{
Brush brush;
if (hit)
{
brush = Brushes.HitBackground;
}
else
{
brush = Brushes.MissedBackground;
}
drawingContext.DrawRectangle(brush, Pen,
new Rect(0, rc.Top, textView.ActualWidth, rc.Height));
}
}
}
public override void Render(DrawingContext drawingContext)
{
base.Render(drawingContext);
var selectionBorder = _textArea.SelectionBorder;
var geoBuilder = new BackgroundGeometryBuilder
{
AlignToWholePixels = true,
BorderThickness = selectionBorder?.Thickness ?? 0,
ExtendToFullWidthAtLineEnd = _textArea.Selection.EnableVirtualSpace,
CornerRadius = _textArea.SelectionCornerRadius
};
foreach (var segment in _textArea.Selection.Segments)
{
geoBuilder.AddSegment(TextView, segment);
}
var geometry = geoBuilder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(_textArea.SelectionBrush, selectionBorder, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (this.renderedReferences == null)
{
return;
}
BackgroundGeometryBuilder builder = new BackgroundGeometryBuilder();
builder.CornerRadius = cornerRadius;
builder.AlignToMiddleOfPixels = true;
foreach (var reference in this.renderedReferences)
{
builder.AddSegment(textView, new TextSegment()
{
StartOffset = reference.Offset,
Length = reference.Length
});
builder.CloseFigure();
}
Geometry geometry = builder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(backgroundBrush, borderPen, geometry);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (this._editor.Document == null)
{
return;
}
try
{
textView.EnsureVisualLines();
var currentLine = this._editor.Document.GetLineByOffset(this._editor.CaretOffset);
foreach (var rect in BackgroundGeometryBuilder.GetRectsForSegment(textView, currentLine))
{
if (textView.ActualWidth - 32 > 0 && rect.Height > 0)
{
var Size = new Size(textView.ActualWidth - 32, rect.Height);
var Rect = new Rect(rect.Location, Size);
drawingContext.DrawRectangle(new SolidColorBrush(Color.FromArgb(50, 250, 250, 100)), null, Rect);
}
}
}
catch (Exception error)
{
Framework.EventBus.Publish(error);
}
}
public void Draw(TextView textView, System.Windows.Media.DrawingContext drawingContext)
{
ISegment s = element.Segment;
if (s != null)
{
BackgroundGeometryBuilder geoBuilder = new BackgroundGeometryBuilder();
geoBuilder.AlignToMiddleOfPixels = true;
if (Layer == KnownLayer.Background)
{
geoBuilder.AddSegment(textView, s);
drawingContext.DrawGeometry(backgroundBrush, null, geoBuilder.CreateGeometry());
}
else
{
// draw foreground only if active
if (element.isCaretInside)
{
geoBuilder.AddSegment(textView, s);
foreach (BoundActiveElement boundElement in element.context.ActiveElements.OfType <BoundActiveElement>())
{
if (boundElement.targetElement == element)
{
geoBuilder.AddSegment(textView, boundElement.Segment);
geoBuilder.CloseFigure();
}
}
drawingContext.DrawGeometry(null, activeBorderPen, geoBuilder.CreateGeometry());
}
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (textView.Document == null /*|| !_isFocused.Value*/)
{
_commentsPanel.HighlightLine(0);
return;
}
DocumentLine line = _editor.Document.GetLineByOffset(_editor.CaretOffset);
_commentsPanel.HighlightLine(line.LineNumber);
textView.EnsureVisualLines();
foreach (Rect r in BackgroundGeometryBuilder.GetRectsForSegment(textView, new TextSegment()
{
StartOffset = line.Offset
}))
{
drawingContext.DrawRectangle(
_brush, // Строка
_pen, // Рамка
new Rect(r.Location, new Size(Math.Max(_editor.ExtentWidth, _editor.ViewportWidth), r.Height))
);
}
}
