/// <inheritdoc/>
public override void Draw(object dc, ImageShape image, double dx, double dy, object db, object r)
{
var _dc = dc as AM.DrawingContext;
var rect = CreateRect(image.TopLeft, image.BottomRight, dx, dy);
if (image.IsStroked || image.IsFilled)
{
AM.IBrush brush = ToBrush(image.Style.Fill);
AM.Pen pen = ToPen(image.Style, _scaleToPage);
DrawRectangleInternal(
_dc,
brush,
pen,
image.IsStroked,
image.IsFilled,
ref rect);
}
if (_enableImageCache &&
_biCache.ContainsKey(image.Key))
{
try
{
var bi = _biCache[image.Key];
_dc.DrawImage(
bi,
1.0,
new A.Rect(0, 0, bi.PixelWidth, bi.PixelHeight),
new A.Rect(rect.X, rect.Y, rect.Width, rect.Height));
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
else
{
if (State.ImageCache == null || string.IsNullOrEmpty(image.Key))
{
return;
}
try
{
var bytes = State.ImageCache.GetImage(image.Key);
if (bytes != null)
{
using (var ms = new System.IO.MemoryStream(bytes))
{
var bi = new AMI.Bitmap(ms);
if (_enableImageCache)
{
_biCache[image.Key] = bi;
}
_dc.DrawImage(
bi,
1.0,
new A.Rect(0, 0, bi.PixelWidth, bi.PixelHeight),
new A.Rect(rect.X, rect.Y, rect.Width, rect.Height));
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, RectangleShape rectangle, double dx, double dy, object db, object r)
{
var _dc = dc as AM.DrawingContext;
AM.IBrush brush = ToBrush(rectangle.Style.Fill);
AM.Pen pen = ToPen(rectangle.Style, _scaleToPage);
var rect = CreateRect(rectangle.TopLeft, rectangle.BottomRight, dx, dy);
DrawRectangleInternal(
_dc,
brush,
pen,
rectangle.IsStroked,
rectangle.IsFilled,
ref rect);
if (rectangle.IsGrid)
{
DrawGridInternal(
_dc,
pen,
ref rect,
rectangle.OffsetX, rectangle.OffsetY,
rectangle.CellWidth, rectangle.CellHeight,
true);
}
}
/// <inheritdoc/>
public override void Draw(object dc, QuadraticBezierShape quadraticBezier, double dx, double dy, object db, object r)
{
if (!quadraticBezier.IsFilled && !quadraticBezier.IsStroked)
{
return;
}
var _dc = dc as AM.DrawingContext;
AM.IBrush brush = ToBrush(quadraticBezier.Style.Fill);
AM.Pen pen = ToPen(quadraticBezier.Style, _scaleToPage);
var sg = new AM.StreamGeometry();
using (var sgc = sg.Open())
{
sgc.BeginFigure(
new A.Point(quadraticBezier.Point1.X, quadraticBezier.Point1.Y),
quadraticBezier.IsFilled);
sgc.QuadraticBezierTo(
new A.Point(quadraticBezier.Point2.X, quadraticBezier.Point2.Y),
new A.Point(quadraticBezier.Point3.X, quadraticBezier.Point3.Y));
sgc.EndFigure(false);
}
_dc.DrawGeometry(
quadraticBezier.IsFilled ? brush : null,
quadraticBezier.IsStroked ? pen : null,
sg);
}
private void DrawLineArrowsInternal(AM.DrawingContext dc, LineShape line, double dx, double dy, out A.Point pt1, out A.Point pt2)
{
AM.IBrush fillStartArrow = ToBrush(line.Style.StartArrowStyle.Fill);
AM.Pen strokeStartArrow = ToPen(line.Style.StartArrowStyle, _scaleToPage);
AM.IBrush fillEndArrow = ToBrush(line.Style.EndArrowStyle.Fill);
AM.Pen strokeEndArrow = ToPen(line.Style.EndArrowStyle, _scaleToPage);
double _x1 = line.Start.X + dx;
double _y1 = line.Start.Y + dy;
double _x2 = line.End.X + dx;
double _y2 = line.End.Y + dy;
line.GetMaxLength(ref _x1, ref _y1, ref _x2, ref _y2);
float x1 = _scaleToPage(_x1);
float y1 = _scaleToPage(_y1);
float x2 = _scaleToPage(_x2);
float y2 = _scaleToPage(_y2);
var sas = line.Style.StartArrowStyle;
var eas = line.Style.EndArrowStyle;
double a1 = Math.Atan2(y1 - y2, x1 - x2);
double a2 = Math.Atan2(y2 - y1, x2 - x1);
// Draw start arrow.
pt1 = DrawLineArrowInternal(dc, strokeStartArrow, fillStartArrow, x1, y1, a1, sas);
// Draw end arrow.
pt2 = DrawLineArrowInternal(dc, strokeEndArrow, fillEndArrow, x2, y2, a2, eas);
}
/// <inheritdoc/>
public override void Draw(object dc, XCubicBezier cubicBezier, double dx, double dy, ImmutableArray <XProperty> db, XRecord r)
{
if (!cubicBezier.IsFilled && !cubicBezier.IsStroked)
{
return;
}
var _dc = dc as AM.DrawingContext;
AM.IBrush brush = ToBrush(cubicBezier.Style.Fill);
AM.Pen pen = ToPen(cubicBezier.Style, _scaleToPage);
var sg = new AM.StreamGeometry();
using (var sgc = sg.Open())
{
sgc.BeginFigure(
new A.Point(cubicBezier.Point1.X, cubicBezier.Point1.Y),
cubicBezier.IsFilled);
sgc.CubicBezierTo(
new A.Point(cubicBezier.Point2.X, cubicBezier.Point2.Y),
new A.Point(cubicBezier.Point3.X, cubicBezier.Point3.Y),
new A.Point(cubicBezier.Point4.X, cubicBezier.Point4.Y));
sgc.EndFigure(false);
}
_dc.DrawGeometry(
cubicBezier.IsFilled ? brush : null,
cubicBezier.IsStroked ? pen : null,
sg);
}
private static void DrawEllipseInternal(AM.DrawingContext dc, AM.IBrush brush, AM.Pen pen, bool isStroked, bool isFilled, ref Rect2 rect)
{
if (!isFilled && !isStroked)
{
return;
}
var r = new A.Rect(rect.X, rect.Y, rect.Width, rect.Height);
var g = new AM.EllipseGeometry(r);
dc.DrawGeometry(
isFilled ? brush : null,
isStroked ? pen : null,
g);
}
/// <inheritdoc/>
public override void Draw(object dc, EllipseShape ellipse, double dx, double dy, object db, object r)
{
var _dc = dc as AM.DrawingContext;
AM.IBrush brush = ToBrush(ellipse.Style.Fill);
AM.Pen pen = ToPen(ellipse.Style, _scaleToPage);
var rect = CreateRect(ellipse.TopLeft, ellipse.BottomRight, dx, dy);
DrawEllipseInternal(
_dc,
brush,
pen,
ellipse.IsStroked,
ellipse.IsFilled,
ref rect);
}
public BraceMatcherHighlightRenderer(TextView textView, IClassificationHighlightColors classificationHighlightColors)
{
_textView = textView ?? throw new ArgumentNullException(nameof(textView));
_textView.BackgroundRenderers.Add(this);
var brush = classificationHighlightColors
.GetBrush(ClassificationHighlightColors.BraceMatchingClassificationTypeName)
?.Background?.GetBrush(null);
if (brush != null)
{
_backgroundBrush = brush;
}
else
{
_backgroundBrush = Brushes.Transparent;
}
}
private static void DrawRectangleInternal(AM.DrawingContext dc, AM.IBrush brush, AM.Pen pen, bool isStroked, bool isFilled, ref Rect2 rect)
{
if (!isStroked && !isFilled)
{
return;
}
var r = new A.Rect(rect.X, rect.Y, rect.Width, rect.Height);
if (isFilled)
{
dc.FillRectangle(brush, r);
}
if (isStroked)
{
dc.DrawRectangle(pen, r);
}
}
/// <inheritdoc/>
public override void Draw(object dc, ArcShape arc, double dx, double dy, object db, object r)
{
if (!arc.IsFilled && !arc.IsStroked)
{
return;
}
var _dc = dc as AM.DrawingContext;
AM.IBrush brush = ToBrush(arc.Style.Fill);
AM.Pen pen = ToPen(arc.Style, _scaleToPage);
var sg = new AM.StreamGeometry();
using (var sgc = sg.Open())
{
var a = new WpfArc(
Point2.FromXY(arc.Point1.X, arc.Point1.Y),
Point2.FromXY(arc.Point2.X, arc.Point2.Y),
Point2.FromXY(arc.Point3.X, arc.Point3.Y),
Point2.FromXY(arc.Point4.X, arc.Point4.Y));
sgc.BeginFigure(
new A.Point(a.Start.X + dx, a.Start.Y),
arc.IsFilled);
sgc.ArcTo(
new A.Point(a.End.X + dx, a.End.Y + dy),
new A.Size(a.Radius.Width, a.Radius.Height),
0.0,
a.IsLargeArc,
AM.SweepDirection.Clockwise);
sgc.EndFigure(false);
}
_dc.DrawGeometry(
arc.IsFilled ? brush : null,
arc.IsStroked ? pen : null,
sg);
}
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))
{
CommonBrush foregroundBrush = null;
if (marker.ForegroundColor != null)
{
foregroundBrush = new SolidColorBrush(marker.ForegroundColor.Value).AsFrozen();
}
ChangeLinePart(
Math.Max(marker.StartOffset, lineStart),
Math.Min(marker.EndOffset, lineEnd),
element =>
{
if (foregroundBrush != null)
{
element.TextRunProperties.SetForegroundBrush(foregroundBrush);
}
var tf = element.TextRunProperties.Typeface;
#if AVALONIA
element.TextRunProperties.Typeface = tf;
#else
element.TextRunProperties.SetTypeface(new Typeface(
tf.FontFamily,
marker.FontStyle ?? tf.Style,
marker.FontWeight ?? tf.Weight,
tf.Stretch
));
#endif
}
);
}
}
/// <inheritdoc/>
public override void Draw(object dc, XArc arc, double dx, double dy, ImmutableArray <XProperty> db, XRecord r)
{
if (!arc.IsFilled && !arc.IsStroked)
{
return;
}
var _dc = dc as AM.DrawingContext;
AM.IBrush brush = ToBrush(arc.Style.Fill);
AM.Pen pen = ToPen(arc.Style, _scaleToPage);
var sg = new AM.StreamGeometry();
using (var sgc = sg.Open())
{
var a = WpfArc.FromXArc(arc, dx, dy);
sgc.BeginFigure(
new A.Point(a.Start.X, a.Start.Y),
arc.IsFilled);
sgc.ArcTo(
new A.Point(a.End.X, a.End.Y),
new A.Size(a.Radius.Width, a.Radius.Height),
0.0,
a.IsLargeArc,
AM.SweepDirection.Clockwise);
sgc.EndFigure(false);
}
_dc.DrawGeometry(
arc.IsFilled ? brush : null,
arc.IsStroked ? pen : null,
sg);
}
/// <inheritdoc/>
public override void Draw(object dc, TextShape text, double dx, double dy, object db, object r)
{
var _gfx = dc as AM.DrawingContext;
var properties = (ImmutableArray <Property>)db;
var record = (Record)r;
var tbind = text.BindText(properties, record);
if (string.IsNullOrEmpty(tbind))
{
return;
}
AM.IBrush brush = ToBrush(text.Style.Stroke);
var fontStyle = AM.FontStyle.Normal;
var fontWeight = AM.FontWeight.Normal;
//var fontDecoration = PM.FontDecoration.None;
if (text.Style.TextStyle.FontStyle != null)
{
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(FontStyleFlags.Italic))
{
fontStyle |= AM.FontStyle.Italic;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(FontStyleFlags.Bold))
{
fontWeight |= AM.FontWeight.Bold;
}
// TODO: Implement font decoration after Avalonia adds support.
/*
* if (text.Style.TextStyle.FontStyle.Flags.HasFlag(FontStyleFlags.Underline))
* {
* fontDecoration |= PM.FontDecoration.Underline;
* }
*
* if (text.Style.TextStyle.FontStyle.Flags.HasFlag(FontStyleFlags.Strikeout))
* {
* fontDecoration |= PM.FontDecoration.Strikethrough;
* }
*/
}
if (text.Style.TextStyle.FontSize >= 0.0)
{
var tf = new AM.Typeface(
text.Style.TextStyle.FontName,
text.Style.TextStyle.FontSize * _textScaleFactor,
fontStyle,
fontWeight);
var ft = new AM.FormattedText()
{
Typeface = tf,
Text = tbind,
TextAlignment = AM.TextAlignment.Left,
Wrapping = AM.TextWrapping.NoWrap
};
var rect = CreateRect(text.TopLeft, text.BottomRight, dx, dy);
var size = ft.Measure();
var origin = GetTextOrigin(text.Style, ref rect, ref size);
_gfx.DrawText(brush, origin, ft);
}
}
private static A.Point DrawLineArrowInternal(AM.DrawingContext dc, AM.Pen pen, AM.IBrush brush, float x, float y, double angle, ArrowStyle style)
{
A.Point pt = default(A.Point);
var rt = APAZ.MatrixHelper.Rotation(angle, new A.Vector(x, y));
double rx = style.RadiusX;
double ry = style.RadiusY;
double sx = 2.0 * rx;
double sy = 2.0 * ry;
switch (style.ArrowType)
{
default:
case ArrowType.None:
{
pt = new A.Point(x, y);
}
break;
case ArrowType.Rectangle:
{
pt = APAZ.MatrixHelper.TransformPoint(rt, new A.Point(x - (float)sx, y));
var rect = new Rect2(x - sx, y - ry, sx, sy);
using (var d = dc.PushPreTransform(rt))
{
DrawRectangleInternal(dc, brush, pen, style.IsStroked, style.IsFilled, ref rect);
}
}
break;
case ArrowType.Ellipse:
{
pt = APAZ.MatrixHelper.TransformPoint(rt, new A.Point(x - (float)sx, y));
using (var d = dc.PushPreTransform(rt))
{
var rect = new Rect2(x - sx, y - ry, sx, sy);
DrawEllipseInternal(dc, brush, pen, style.IsStroked, style.IsFilled, ref rect);
}
}
break;
case ArrowType.Arrow:
{
var pts = new A.Point[]
{
new A.Point(x, y),
new A.Point(x - (float)sx, y + (float)sy),
new A.Point(x, y),
new A.Point(x - (float)sx, y - (float)sy),
new A.Point(x, y)
};
pt = APAZ.MatrixHelper.TransformPoint(rt, pts[0]);
var p11 = APAZ.MatrixHelper.TransformPoint(rt, pts[1]);
var p21 = APAZ.MatrixHelper.TransformPoint(rt, pts[2]);
var p12 = APAZ.MatrixHelper.TransformPoint(rt, pts[3]);
var p22 = APAZ.MatrixHelper.TransformPoint(rt, pts[4]);
DrawLineInternal(dc, pen, style.IsStroked, ref p11, ref p21);
DrawLineInternal(dc, pen, style.IsStroked, ref p12, ref p22);
}
break;
}
return(pt);
}
