protected override void ColorizeLine(DocumentLine line)
{
if (markers == null)
{
return;
}
int lineStart = line.Offset;
int lineEnd = lineStart + line.Length;
foreach (TextMarker marker in markers.FindOverlappingSegments(lineStart, line.Length))
{
Brush foregroundBrush = null;
if (marker.ForegroundColor != null)
{
foregroundBrush = new SolidColorBrush(marker.ForegroundColor.Value);
foregroundBrush.Freeze();
}
ChangeLinePart(
Math.Max(marker.StartOffset, lineStart),
Math.Min(marker.EndOffset, lineEnd),
element => {
if (foregroundBrush != null)
{
element.TextRunProperties.SetForegroundBrush(foregroundBrush);
}
}
);
}
}
/// <summary>
/// Gets the deletable segments inside the given segment.
/// </summary>
public virtual IEnumerable <ISegment> GetDeletableSegments(ISegment segment)
{
if (segment == null)
{
throw new ArgumentNullException("segment");
}
int readonlyUntil = segment.Offset;
foreach (TextSegment ts in segments.FindOverlappingSegments(segment))
{
int start = ts.StartOffset;
int end = start + ts.Length;
if (start > readonlyUntil)
{
yield return(new SimpleSegment(readonlyUntil, start - readonlyUntil));
}
if (end > readonlyUntil)
{
readonlyUntil = end;
}
}
int endOffset = segment.EndOffset;
if (readonlyUntil < endOffset)
{
yield return(new SimpleSegment(readonlyUntil, endOffset - readonlyUntil));
}
}
public void UpdateOffsetsAndInvalidate(IEnumerable <DocumentChangeEventArgs> changes)
{
foreach (DocumentChangeEventArgs change in changes)
{
// Update offsets of all items
segments.UpdateOffsets(change);
// Remove any items affected by the change
AXmlParser.Log("Changed {0}-{1}", change.Offset, change.Offset + change.InsertionLength);
// Removing will cause one of the ends to be set to change.Offset
// FindSegmentsContaining includes any segments touching
// so that conviniently takes care of the +1 byte
var segmentsContainingOffset = segments.FindOverlappingSegments(change.Offset, change.InsertionLength);
foreach (AXmlObject obj in segmentsContainingOffset.OfType <AXmlObject>().Where(o => o.IsCached))
{
InvalidateCache(obj, false);
}
foreach (TouchedRange range in segmentsContainingOffset.OfType <TouchedRange>())
{
AXmlParser.Log("Found that {0} dependeds on ({1}-{2})", range.TouchedByObject, range.StartOffset, range.EndOffset);
InvalidateCache(range.TouchedByObject, true);
segments.Remove(range);
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (textView == null)
{
throw new ArgumentNullException(nameof(textView));
}
if (drawingContext == null)
{
throw new ArgumentNullException(nameof(drawingContext));
}
if (diffSegments == null || !textView.VisualLinesValid)
{
return;
}
var visualLines = textView.VisualLines;
if (visualLines.Count == 0)
{
return;
}
int viewStart = visualLines.First().FirstDocumentLine.Offset;
int viewEnd = visualLines.Last().LastDocumentLine.EndOffset;
var segmentsOnScreen = diffSegments.FindOverlappingSegments(viewStart, viewEnd - viewStart);
foreach (DiffSegment segment in segmentsOnScreen)
{
DrawSegment(segment, textView, drawingContext);
}
}
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 (Issues == null)
{
return;
}
var segments = new TextSegmentCollection <IssueMarker>();
foreach (var issue in Issues)
{
segments.Add(new IssueMarker(Theme, issue));
}
var visualLines = textView.VisualLines;
if (visualLines.Count == 0)
{
return;
}
int viewStart = visualLines.First().FirstDocumentLine.Offset;
int viewEnd = visualLines.Last().LastDocumentLine.EndOffset;
foreach (var marker in segments.FindOverlappingSegments(viewStart, viewEnd - viewStart))
{
var brush = marker.Brush;
var usedPen = new Pen(brush, 1);
usedPen.Freeze();
if (brush == null)
{
continue;
}
foreach (var r in BackgroundGeometryBuilder.GetRectsForSegment(textView, marker))
{
var startPoint = r.BottomLeft;
var endPoint = r.BottomRight;
double offset = 2.5;
int count = Math.Max((int)((endPoint.X - startPoint.X) / offset) + 1, 4);
var geometry = new StreamGeometry();
using (StreamGeometryContext ctx = geometry.Open())
{
ctx.BeginFigure(startPoint, false, false);
ctx.PolyLineTo(CreatePoints(startPoint, offset, count), true, false);
}
geometry.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, usedPen, geometry);
}
}
}
IEnumerable <TextMarker> GetSortedTextMarkers(int lineStart, int lineLength)
{
if (markers == null)
{
return(new TextMarker[0]);
}
var list = new List <TextMarker>(markers.FindOverlappingSegments(lineStart, lineLength));
list.Sort((a, b) => a.ZOrder.CompareTo(b.ZOrder));
return(list);
}
protected override void TransformLine(DocumentLine line, ITextRunConstructionContext context)
{
int i = line.LineNumber;
var tokens = _model.GetLineTokens(i - 1);
if (tokens == null)
{
return;
}
RemoveLineTransformations(i);
ProcessTokens(i, tokens);
var transformsInLine = _transformations.FindOverlappingSegments(line);
foreach (var transform in transformsInLine)
{
transform.Transform(this, line);
}
}
protected override void ColorizeLine(DocumentLine line)
{
if (markers == null)
{
return;
}
var lineStart = line.Offset;
var lineEnd = lineStart + line.Length;
foreach (var marker in markers.FindOverlappingSegments(lineStart, line.Length))
{
Brush foregroundBrush = null;
if (marker.ForegroundColor != null)
{
foregroundBrush = new SolidColorBrush(marker.ForegroundColor.Value);
foregroundBrush.Freeze();
}
ChangeLinePart(
Math.Max(marker.StartOffset, lineStart),
Math.Min(marker.EndOffset, lineEnd),
element =>
{
if (foregroundBrush != null)
{
element.TextRunProperties.SetForegroundBrush(foregroundBrush);
}
var tf = element.TextRunProperties.Typeface;
element.TextRunProperties.SetTypeface(new Typeface(
tf.FontFamily,
marker.FontStyle ?? tf.Style,
marker.FontWeight ?? tf.Weight,
tf.Stretch
));
}
);
}
}
protected override void ColorizeLine(DocumentLine line)
{
if (markers == null)
{
return;
}
int lineStart = line.Offset;
int lineEnd = lineStart + line.Length;
foreach (TextMarker marker in markers.FindOverlappingSegments(lineStart, line.Length))
{
Brush foregroundBrush = null;
if (marker.ForegroundColor != null)
{
foregroundBrush = new SolidColorBrush(marker.ForegroundColor.Value);
//foregroundBrush.Freeze();
}
ChangeLinePart(
Math.Max(marker.StartOffset, lineStart),
Math.Min(marker.EndOffset, lineEnd),
element => {
if (foregroundBrush != null)
{
element.TextRunProperties.ForegroundBrush = foregroundBrush;
}
// TODO: change font style
//string tf = element.TextRunProperties.Typeface;
//element.TextRunProperties.SetTypeface(new Typeface(
// tf.FontFamily,
// marker.FontStyle ?? tf.Style,
// marker.FontWeight ?? tf.Weight,
// tf.Stretch
//));
}
);
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (textView == null)
{
throw new ArgumentNullException("textView");
}
if (drawingContext == null)
{
throw new ArgumentNullException("drawingContext");
}
if (currentResults == null || !textView.VisualLinesValid)
{
return;
}
var visualLines = textView.VisualLines;
if (visualLines.Count == 0)
{
return;
}
int viewStart = visualLines.First().FirstDocumentLine.Offset;
int viewEnd = visualLines.Last().LastDocumentLine.EndOffset;
int highlightCounter = 0;
foreach (SearchResult result in currentResults.FindOverlappingSegments(viewStart, viewEnd - viewStart))
{
BackgroundGeometryBuilder geoBuilder = new BackgroundGeometryBuilder();
geoBuilder.AlignToWholePixels = true;
geoBuilder.BorderThickness = markerPen != null ? markerPen.Thickness : 0;
geoBuilder.CornerRadius = 3;
geoBuilder.AddSegment(textView, result);
Geometry geometry = geoBuilder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(markerBrush, markerPen, geometry);
}
highlightCounter++;
if (highlightCounter >= MAX_HIGHLIGHT)
{
break;
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (!markers.Any() || !textView.VisualLinesValid)
{
return;
}
var visualLines = textView.VisualLines;
if (visualLines.Count == 0)
{
return;
}
int viewStart = visualLines.First().FirstDocumentLine.Offset;
int viewEnd = visualLines.Last().LastDocumentLine.EndOffset;
foreach (ErrorTextMarker marker in markers.FindOverlappingSegments(viewStart, viewEnd - viewStart))
{
foreach (Rect rect in BackgroundGeometryBuilder.GetRectsForSegment(textView, marker))
{
Point startPoint = rect.BottomLeft;
Point endPoint = rect.BottomRight;
var pen = new Pen(new SolidColorBrush(marker.MarkerColor), 1);
pen.Freeze();
const double offset = 2.5;
int count = Math.Max((int)((endPoint.X - startPoint.X) / offset) + 1, 4);
var geometry = new StreamGeometry();
using (StreamGeometryContext ctx = geometry.Open())
{
ctx.BeginFigure(startPoint, false, false);
ctx.PolyLineTo(CreatePoints(startPoint, offset, count).ToArray(), true, false);
}
geometry.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, pen, geometry);
break;
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (textView == null)
{
throw new ArgumentNullException(nameof(textView));
}
if (drawingContext == null)
{
throw new ArgumentNullException(nameof(drawingContext));
}
if (currentResults == null || !textView.VisualLinesValid)
{
return;
}
var visualLines = textView.VisualLines;
if (visualLines.Count == 0)
{
return;
}
int viewStart = visualLines.First().FirstDocumentLine.Offset;
int viewEnd = visualLines.Last().LastDocumentLine.EndOffset;
foreach (SearchResult result in currentResults.FindOverlappingSegments(viewStart, viewEnd - viewStart))
{
BackgroundGeometryBuilder geoBuilder = new BackgroundGeometryBuilder();
geoBuilder.AlignToMiddleOfPixels = true;
geoBuilder.CornerRadius = 0;
geoBuilder.AddSegment(textView, result);
Geometry geometry = geoBuilder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(markerBrush, markerPen, geometry);
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
// validate parameters
if (textView == null)
{
throw new ArgumentNullException(nameof(textView));
}
if (drawingContext == null)
{
throw new ArgumentNullException(nameof(drawingContext));
}
if (markers != null && textView.VisualLinesValid)
{
var visualLines = textView.VisualLines;
if (visualLines.Count == 0)
{
return;
}
int viewStart = visualLines.First().FirstDocumentLine.Offset;
int viewEnd = visualLines.Last().LastDocumentLine.EndOffset;
foreach (TextMarker marker in markers.FindOverlappingSegments(viewStart, viewEnd - viewStart))
{
if (marker.BackgroundColor != null)
{
var geoBuilder = new BackgroundGeometryBuilder {
AlignToWholePixels = true, CornerRadius = 3
};
geoBuilder.AddSegment(textView, marker);
Geometry geometry = geoBuilder.CreateGeometry();
if (geometry != null)
{
Color color = marker.BackgroundColor.Value;
var brush = new SolidColorBrush(color);
brush.Freeze();
drawingContext.DrawGeometry(brush, null, geometry);
}
}
foreach (Rect r in BackgroundGeometryBuilder.GetRectsForSegment(textView, marker))
{
Point startPoint = r.BottomLeft;
Point endPoint = r.BottomRight;
double yOffset = 1;
startPoint.Offset(0, yOffset);
endPoint.Offset(0, yOffset);
var usedPen = new Pen(new SolidColorBrush(marker.MarkerColor), 1);
usedPen.Freeze();
const double offset = 2.5;
int count = Math.Max((int)((endPoint.X - startPoint.X) / offset) + 1, 4);
var geometry = new StreamGeometry();
using (StreamGeometryContext ctx = geometry.Open())
{
ctx.BeginFigure(startPoint, false, false);
ctx.PolyLineTo(CreatePoints(startPoint, offset, count).ToArray(), true, false);
}
geometry.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, usedPen, geometry);
break;
}
}
}
}
public void 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 (BackgroundColor != null)
{
BackgroundGeometryBuilder geoBuilder = new BackgroundGeometryBuilder
{
AlignToWholePixels = true,
CornerRadius = 3
};
geoBuilder.AddSegment(textView, marker);
Geometry geometry = geoBuilder.CreateGeometry();
if (geometry != null)
{
drawingContext.DrawGeometry(BackgroundColor, null, geometry);
}
}
foreach (var r in BackgroundGeometryBuilder.GetRectsForSegment(textView, marker))
{
Point startPoint = r.BottomLeft;
Point endPoint = r.BottomRight;
if ((MarkerType & TextMarkerTypes.SquigglyUnderline) != 0)
{
double offset = 2.5;
int count = Math.Max((int)((endPoint.X - startPoint.X) / offset) + 1, 4);
StreamGeometry geometry = new StreamGeometry();
using (StreamGeometryContext ctx = geometry.Open())
{
ctx.BeginFigure(startPoint, false, false);
ctx.PolyLineTo(CreatePoints(startPoint, endPoint, offset, count).ToArray(), true, false);
}
geometry.Freeze();
Pen usedPen = new Pen(ForegroundColor, 1);
usedPen.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, usedPen, geometry);
}
if ((MarkerType & TextMarkerTypes.NormalUnderline) != 0)
{
Pen usedPen = new Pen(ForegroundColor, 1);
usedPen.Freeze();
drawingContext.DrawLine(usedPen, startPoint, endPoint);
}
if ((MarkerType & TextMarkerTypes.DottedUnderline) != 0)
{
Pen usedPen = new Pen(ForegroundColor, 1)
{
DashStyle = DashStyles.Dot
};
usedPen.Freeze();
drawingContext.DrawLine(usedPen, startPoint, endPoint);
}
if ((MarkerType & TextMarkerTypes.Rectangle) != 0)
{
Pen usedPen = new Pen(ForegroundColor, 1);
usedPen.Freeze();
drawingContext.DrawRectangle(null, usedPen, r);
}
}
}
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
if (textView == null)
{
throw new ArgumentNullException(nameof(textView));
}
if (drawingContext == null)
{
throw new ArgumentNullException(nameof(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;
if (IsActiveDebugging && marker.Bookmark != null && marker.Bookmark.BookmarkType == BookmarkType.Breakpoint)
{
color.A = 0x77;
}
else
{
color.A = 0xff;
}
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;
Brush usedBrush = new SolidColorBrush(marker.MarkerColor);
usedBrush.Freeze();
var 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, offset, count).ToArray(), true, false);
}
geometry.Freeze();
var usedPen = new Pen(usedBrush, 1);
usedPen.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, usedPen, geometry);
}
}
}
