private void CanvasAnimatedControl_OnDraw(ICanvasAnimatedControl sender, CanvasAnimatedDrawEventArgs args)
{
for (int i = 0; i <= _ringCount; i++)
{
var currentOffset = StartOffset + i*(RingPadding + RingStrokeWidth);
using (var c = new CanvasPathBuilder(sender))
{
c.BeginFigure(currentOffset, 0.0f);
c.AddArc(new Vector2(0.0f, 0.0f), currentOffset, currentOffset, 0.0f, (float)(Math.PI * 2));
c.EndFigure(CanvasFigureLoop.Open);
using (var g = CanvasGeometry.CreatePath(c))
{
var m = _pattern[_animationCounter + (_ringCount - i)];
_brush.Transform = Matrix3x2.CreateRotation((float)(Math.PI * 2 * m), _center);
using (args.DrawingSession.CreateLayer(_brush))
{
args.DrawingSession.DrawGeometry(g, _center, Color.FromArgb(255,
m < 0.5 ? Convert.ToByte(Math.Floor(m * 2 * 255)) : Convert.ToByte(Math.Floor((1.5 - m) * 255)),
m < 0.5 ? (byte)128 : Convert.ToByte(Math.Floor(m * 255)),
255), RingStrokeWidth);
}
}
}
}
_animationCounter++;
if (_animationCounter > _pattern.Count - _ringCount - 1) _animationCounter = 0;
}
internal override void drawPath(CanvasPathBuilder p, Stroke stroke)
{
setGraphics(canvas.CreateDrawingSession());
base.setClip(clip);
base.drawPath(p, stroke);
base.removeClip();
}
public void beginPath()
{
if (this.pathBuilder != null) {
closePath();
}
this.pathBuilder = new CanvasPathBuilder(CanvasDevice.GetSharedDevice());
}
public PathInfo(ICanvasResourceCreator rc, Windows.UI.Color color, System.Single strokeWidth, CanvasStrokeStyle strokeStyle) //Pen pen, bool fill, int shapeType)
{
Vector2 offset = new Vector2(0.0f, 0.0f);
_cpb = new CanvasPathBuilder(rc);
//_cpb.SetSegmentOptions(CanvasFigureSegmentOptions.ForceRoundLineJoin);
_color = color;
//_fill = fill;
//_type = shapeType;
}
public PathInfo(ICanvasResourceCreator rc, Windows.UI.Color color, System.Single strokeWidth, bool fill, int shapeType) //Pen pen, bool fill, int shapeType)
{
Vector2 offset = new Vector2(0.0f, 0.0f);
_cpb = new CanvasPathBuilder(rc);
_color = color;
_fill = fill;
_type = shapeType;
CanvasGeometry path = CanvasGeometry.CreatePath(_cpb);
//path.ComputeBounds
//var geometry = CanvasGeometry.CreatePath(pathBuilder);
}
internal virtual void drawArc(int x, int y, int w, int h, int startAngle, int arcAngle)
{
Vector2 center = new Vector2();
center.X = x + w / 2;
center.Y = y + h / 2;
if (arcAngle == 360)
graphics.DrawEllipse(center, w / 2, h / 2, c);
else
{
CanvasPathBuilder builder = new CanvasPathBuilder(graphics);
builder.BeginFigure(center);
builder.AddArc(center, w / 2, h / 2, -(float)(2 * Math.PI * startAngle / 360), -(float)(2 * Math.PI * arcAngle / 360));
builder.EndFigure(CanvasFigureLoop.Closed);
graphics.DrawGeometry(CanvasGeometry.CreatePath(builder), c);
}
}
public void Draw(ICanvasAnimatedControl sender, CanvasDrawingSession drawingSession)
{
if (currentThunder == null)
{
return;
}
// 保护原先画布的混合模式
var previousBlend = drawingSession.Blend;
drawingSession.Blend = blendState;
var builder = new CanvasPathBuilder(sender);
builder.BeginFigure(0, 0);
for (int i = 0; i < currentThunder.LifeLong; i++)
{
builder.AddLine(currentThunder.Path[i].X, currentThunder.Path[i].Y);
}
builder.EndFigure(CanvasFigureLoop.Open);
builder.SetSegmentOptions(CanvasFigureSegmentOptions.ForceRoundLineJoin);
// Draw the particle.
var path = CanvasGeometry.CreatePath(builder);
var NormalizeLifeTime = currentThunder.TimeSinceStart / currentThunder.Duration;
byte opacity = (byte)((NormalizeLifeTime - 1) * (NormalizeLifeTime - 1) * 255);
CanvasCommandList cl = new CanvasCommandList(sender);
using (CanvasDrawingSession clds = cl.CreateDrawingSession())
{
clds.DrawGeometry(path, currentThunder.Position, Color.FromArgb((byte)(0.75f * opacity), 255, 255, 255), 6 * currentThunder.Luminace);
}
var lightAmount = 20.6f * currentThunder.Luminace * (NormalizeLifeTime - 1) * (NormalizeLifeTime - 1);
blur.Source = cl;
blur.BlurAmount = lightAmount;
drawingSession.DrawImage(blur);
drawingSession.DrawGeometry(path, currentThunder.Position, Color.FromArgb(opacity, 255, 240, 180), 2 * currentThunder.Luminace);
drawingSession.Blend = previousBlend;
if (NormalizeLifeTime > 1)
{
currentThunder = null;
}
}
/// <summary>
/// Adds the Path Element to the Path.
/// </summary>
/// <param name="pathBuilder">CanvasPathBuilder object</param>
/// <param name="currentPoint">The last active location in the Path before adding
/// the Path Element</param>
/// <param name="lastElement">The previous PathElement in the Path.</param>
/// <param name="logger">For logging purpose. To log the set of CanvasPathBuilder
/// commands, used for creating the CanvasGeometry, in string format.</param>
/// <returns>The latest location in the Path after adding the Path Element</returns>
public override Vector2 CreatePath(CanvasPathBuilder pathBuilder, Vector2 currentPoint,
ref ICanvasPathElement lastElement, StringBuilder logger)
{
// Calculate coordinates
var point = new Vector2(_x, _y);
if (IsRelative)
{
point += currentPoint;
}
// Execute command
pathBuilder.AddArc(point, _radiusX, _radiusY, _angle, _sweepDirection, _arcSize);
// Log command
logger?.Append($"{Indent}pathBuilder.AddArc(new Vector2({point.X}, {point.Y}), ");
logger?.AppendLine($"{_radiusX}, {_radiusY}, {_angle}, {_sweepDirection}, {_arcSize});");
// Set Last Element
lastElement = this;
// Return current point
return(point);
}
public static CanvasPathBuilder BuildPathWithLines(
this CanvasPathBuilder builder,
IEnumerable <Vector2> vectors,
CanvasFigureLoop canvasFigureLoop)
{
var first = true;
foreach (var vector2 in vectors)
{
if (first)
{
builder.BeginFigure(vector2);
first = false;
}
else
{
builder.AddLine(vector2);
}
}
builder.EndFigure(canvasFigureLoop);
return(builder);
}
// - - - Shape tree root for layer: icon
// - - ShapeGroup: Group 2
CanvasGeometry Geometry_0()
{
CanvasGeometry result;
using (var builder = new CanvasPathBuilder(null))
{
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Winding);
builder.BeginFigure(new Vector2(2.77399993F, -79.1600037F));
builder.AddCubicBezier(new Vector2(1.09399998F, -80.2799988F), new Vector2(-1.09399998F, -80.2799988F), new Vector2(-2.773F, -79.1600037F));
builder.AddCubicBezier(new Vector2(-22.1550007F, -66.2389984F), new Vector2(-43.1170006F, -58.1769981F), new Vector2(-65.7070007F, -54.9500008F));
builder.AddCubicBezier(new Vector2(-68.1699982F, -54.5979996F), new Vector2(-70F, -52.487999F), new Vector2(-70F, -50F));
builder.AddLine(new Vector2(-70F, -5F));
builder.AddCubicBezier(new Vector2(-70F, 33.9129982F), new Vector2(-46.9300003F, 62.3069992F), new Vector2(-1.79499996F, 79.6669998F));
builder.AddCubicBezier(new Vector2(-0.639999986F, 80.1110001F), new Vector2(0.639999986F, 80.1110001F), new Vector2(1.79499996F, 79.6669998F));
builder.AddCubicBezier(new Vector2(46.9300003F, 62.3069992F), new Vector2(70F, 33.9129982F), new Vector2(70F, -5F));
builder.AddLine(new Vector2(70F, -50F));
builder.AddCubicBezier(new Vector2(70F, -52.487999F), new Vector2(68.1699982F, -54.5979996F), new Vector2(65.7070007F, -54.9500008F));
builder.AddCubicBezier(new Vector2(43.1170006F, -58.1769981F), new Vector2(22.1550007F, -66.2389984F), new Vector2(2.77399993F, -79.1600037F));
builder.EndFigure(CanvasFigureLoop.Closed);
result = CanvasGeometry.CreatePath(builder);
}
return(result);
}
private CanvasGeometry CreatePathGeometry(CanvasDrawingSession drawingSession, IEnumerable <Vector2> points, bool close, Matrix3x2 transformMatrix)
{
var pathBuilder = new CanvasPathBuilder(drawingSession);
pathBuilder.BeginFigure(points.First());
foreach (var point in points.Skip(1))
{
pathBuilder.AddLine(Multiply(transformMatrix, point));
}
if (close)
{
pathBuilder.AddLine(Multiply(transformMatrix, new Vector2(1, 1)));
pathBuilder.AddLine(Multiply(transformMatrix, new Vector2(0, 1)));
}
pathBuilder.EndFigure(close ? CanvasFigureLoop.Closed : CanvasFigureLoop.Open);
var geometry = CanvasGeometry.CreatePath(pathBuilder);
return(geometry);
}
private static CanvasGeometry CreatePieCore(ICanvasResourceCreator resourceCreator, Matrix3x2 oneMatrix, float sweepAngle)
{
// start tooth
Vector2 startTooth = new Vector2(1, 0);
// end tooth
Vector2 endTooth = TransformerGeometry.GetRotationVector(sweepAngle);
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(resourceCreator);
CanvasArcSize canvasArcSize = (sweepAngle < System.Math.PI) ? CanvasArcSize.Large : CanvasArcSize.Small;
{
pathBuilder.BeginFigure(Vector2.Zero);
// end notch point
pathBuilder.AddLine(endTooth);
// end tooth point
pathBuilder.AddArc(startTooth, 1, 1, sweepAngle, CanvasSweepDirection.Clockwise, canvasArcSize);
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
}
return(CanvasGeometry.CreatePath(pathBuilder).Transform(oneMatrix));
}
private static CanvasGeometry BuildGeometry(ICanvasResourceCreator resourceCreator, IReadOnlyList <Vector2> points)
{
using (var builder = new CanvasPathBuilder(resourceCreator.Device))
{
builder.BeginFigure(points[0]);
for (var i = 0; i < points.Count / 3; i++)
{
builder.AddQuadraticBezier(points[(i * 3) + 1], points[(i * 3) + 2]);
var lastIndex = (i * 3) + 3;
if (lastIndex < points.Count - 1)
{
builder.AddLine(points[lastIndex]);
}
}
builder.EndFigure(CanvasFigureLoop.Closed);
return(CanvasGeometry.CreatePath(builder));
}
}
private static CanvasGeometry CreateFilledPath(ICanvasResourceCreator session, Vector2 point1, Vector2 point2)
{
var halfX = (point1.X + point2.X) * 0.5f;
using (var builder = new CanvasPathBuilder(session.Device))
{
builder.BeginFigure(new Vector2(point1.X, point1.Y - StartHeightHalf));
builder.AddCubicBezier(
new Vector2(halfX, point1.Y - StartHeightHalf),
new Vector2(halfX, point2.Y),
new Vector2(point2.X, point2.Y));
builder.AddLine(point2.X, point2.Y);
builder.AddCubicBezier(
new Vector2(halfX, point2.Y),
new Vector2(halfX, point1.Y + StartHeightHalf),
new Vector2(point1.X, point1.Y + StartHeightHalf));
builder.EndFigure(CanvasFigureLoop.Closed);
return(CanvasGeometry.CreatePath(builder));
}
}
// - - - - Shape tree root for layer: icon
// - - - ShapeGroup: Group 6
// - - Path 2+Path 1.PathGeometry
CanvasGeometry Geometry_2()
{
CanvasGeometry result;
using (var builder = new CanvasPathBuilder(null))
{
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Winding);
builder.BeginFigure(new Vector2(-70F, -55F));
builder.AddCubicBezier(new Vector2(-70F, -63.2840004F), new Vector2(-63.2840004F, -70F), new Vector2(-55F, -70F));
builder.AddLine(new Vector2(55F, -70F));
builder.AddCubicBezier(new Vector2(63.2840004F, -70F), new Vector2(70F, -63.2840004F), new Vector2(70F, -55F));
builder.AddLine(new Vector2(70F, 15F));
builder.AddCubicBezier(new Vector2(70F, 23.2840004F), new Vector2(63.2840004F, 30F), new Vector2(55F, 30F));
builder.AddLine(new Vector2(0F, 30F));
builder.AddLine(new Vector2(0F, -20F));
builder.AddCubicBezier(new Vector2(0F, -31.0459995F), new Vector2(-8.95400047F, -40F), new Vector2(-20F, -40F));
builder.AddLine(new Vector2(-70F, -40F));
builder.AddLine(new Vector2(-70F, -55F));
builder.EndFigure(CanvasFigureLoop.Closed);
result = CanvasGeometry.CreatePath(builder);
}
return(result);
}
void CanvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args)
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasPathBuilder p = new CanvasPathBuilder(device.Device);
args.DrawingSession.Clear(Colors.LawnGreen);
hex = payload.hex;
point = payload.point;
p.BeginFigure(hex.P1.X, hex.P1.Y);
p.AddLine(hex.P2.X, hex.P2.Y);
p.AddLine(hex.P3.X, hex.P3.Y);
p.AddLine(hex.P4.X, hex.P4.Y);
p.AddLine(hex.P5.X, hex.P5.Y);
p.AddLine(hex.P6.X, hex.P6.Y);
p.AddLine(hex.P1.X, hex.P1.Y);
p.EndFigure(CanvasFigureLoop.Closed);
CanvasGeometry geometry = CanvasGeometry.CreatePath(p);
args.DrawingSession.FillGeometry(geometry, Colors.Red);
string point1 = hex.P1.X + ";" + hex.P1.Y;
string point2 = hex.P2.X + ";" + hex.P2.Y;
string point3 = hex.P3.X + ";" + hex.P3.Y;
string point4 = hex.P4.X + ";" + hex.P4.Y;
string point5 = hex.P5.X + ";" + hex.P5.Y;
string point6 = hex.P6.X + ";" + hex.P6.Y;
args.DrawingSession.DrawText(point1, hex.P1.X, hex.P1.Y, Colors.Black);
args.DrawingSession.DrawText(point2, hex.P2.X, hex.P2.Y, Colors.Black);
args.DrawingSession.DrawText(point3, hex.P3.X, hex.P3.Y, Colors.Black);
args.DrawingSession.DrawText(point4, hex.P4.X, hex.P4.Y, Colors.Black);
args.DrawingSession.DrawText(point5, hex.P5.X, hex.P5.Y, Colors.Black);
args.DrawingSession.DrawText(point6, hex.P6.X, hex.P6.Y, Colors.Black);
string check = hex.IsPointInside(point).ToString();
args.DrawingSession.DrawText(check, point.X, point.Y, Colors.Black);
args.DrawingSession.Flush();
}
private CanvasRenderTarget GetRenderTarget(Size scale, Rect signatureBounds, Size imageSize, float strokeWidth, Color strokeColor, Color backgroundColor)
{
var device = CanvasDevice.GetSharedDevice();
var offscreen = new CanvasRenderTarget(device, (int)imageSize.Width, (int)imageSize.Height, 96);
using (var session = offscreen.CreateDrawingSession())
{
session.Clear(backgroundColor);
session.Transform = Multiply(
CreateTranslation((float)-signatureBounds.X, (float)-signatureBounds.Y),
CreateScale((float)scale.Width, (float)scale.Height));
foreach (var stroke in inkPresenter.GetStrokes())
{
var points = stroke.GetPoints();
var position = points.First();
var builder = new CanvasPathBuilder(device);
builder.BeginFigure((float)position.X, (float)position.Y);
foreach (var point in points)
{
builder.AddLine(new Vector2 {
X = (float)point.X, Y = (float)point.Y
});
}
builder.EndFigure(CanvasFigureLoop.Open);
var path = CanvasGeometry.CreatePath(builder);
var color = strokeColor;
var width = (float)strokeWidth;
session.DrawGeometry(path, color, width);
}
}
return(offscreen);
}
// - - - - Shape tree root for layer: Shape
// - - ShapeGroup: Shape Scale:10,10
CanvasGeometry Geometry()
{
CanvasGeometry result;
using (var builder = new CanvasPathBuilder(null))
{
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Winding);
builder.BeginFigure(new Vector2(0.897000015F, -7.10099983F));
builder.AddCubicBezier(new Vector2(0.529999971F, -7.84399986F), new Vector2(-0.529999971F, -7.84399986F), new Vector2(-0.897000015F, -7.10099983F));
builder.AddLine(new Vector2(-2.5940001F, -3.66100001F));
builder.AddCubicBezier(new Vector2(-2.74000001F, -3.36599994F), new Vector2(-3.02099991F, -3.16100001F), new Vector2(-3.34699988F, -3.11400008F));
builder.AddLine(new Vector2(-7.14400005F, -2.56200004F));
builder.AddCubicBezier(new Vector2(-7.96400023F, -2.44300008F), new Vector2(-8.29199982F, -1.43599999F), new Vector2(-7.69799995F, -0.856999993F));
builder.AddLine(new Vector2(-7.03000021F, -0.206F));
builder.AddCubicBezier(new Vector2(-6.07399988F, 0.726000011F), new Vector2(-4.71799994F, 1.11899996F), new Vector2(-3.41199994F, 0.842999995F));
builder.AddLine(new Vector2(0.342999995F, 0.0500000007F));
builder.AddCubicBezier(new Vector2(0.901000023F, -0.0680000037F), new Vector2(1.16299999F, 0.713F), new Vector2(0.646000028F, 0.954999983F));
builder.AddLine(new Vector2(-2.90400004F, 2.61400008F));
builder.AddCubicBezier(new Vector2(-4.09100008F, 3.16899991F), new Vector2(-4.93100023F, 4.26999998F), new Vector2(-5.15299988F, 5.5619998F));
builder.AddLine(new Vector2(-5.3119998F, 6.48699999F));
builder.AddCubicBezier(new Vector2(-5.45200014F, 7.3039999F), new Vector2(-4.59499979F, 7.92700005F), new Vector2(-3.86100006F, 7.54099989F));
builder.AddLine(new Vector2(-0.465000004F, 5.75600004F));
builder.AddCubicBezier(new Vector2(-0.173999995F, 5.60300016F), new Vector2(0.173999995F, 5.60300016F), new Vector2(0.465000004F, 5.75600004F));
builder.AddLine(new Vector2(3.86100006F, 7.54099989F));
builder.AddCubicBezier(new Vector2(4.59499979F, 7.92700005F), new Vector2(5.45200014F, 7.3039999F), new Vector2(5.3119998F, 6.48699999F));
builder.AddLine(new Vector2(4.66300011F, 2.70600009F));
builder.AddCubicBezier(new Vector2(4.60699987F, 2.38199997F), new Vector2(4.71500015F, 2.05100012F), new Vector2(4.95100021F, 1.82099998F));
builder.AddLine(new Vector2(7.69799995F, -0.856999993F));
builder.AddCubicBezier(new Vector2(8.29199982F, -1.43599999F), new Vector2(7.96400023F, -2.44300008F), new Vector2(7.14400005F, -2.56200004F));
builder.AddLine(new Vector2(3.34699988F, -3.11400008F));
builder.AddCubicBezier(new Vector2(3.02099991F, -3.16100001F), new Vector2(2.74099994F, -3.36599994F), new Vector2(2.59500003F, -3.66100001F));
builder.AddLine(new Vector2(0.897000015F, -7.10099983F));
builder.EndFigure(CanvasFigureLoop.Closed);
result = CanvasGeometry.CreatePath(builder);
}
return(result);
}
private void DrawSelectionLasso(CanvasControl sender, CanvasDrawingSession ds)
{
if (selectionPolylinePoints == null)
{
return;
}
if (selectionPolylinePoints.Count == 0)
{
return;
}
CanvasPathBuilder selectionLasso = new CanvasPathBuilder(canvasControl);
selectionLasso.BeginFigure(selectionPolylinePoints[0].ToVector2());
for (int i = 1; i < selectionPolylinePoints.Count; ++i)
{
selectionLasso.AddLine(selectionPolylinePoints[i].ToVector2());
}
selectionLasso.EndFigure(CanvasFigureLoop.Open);
CanvasGeometry pathGeometry = CanvasGeometry.CreatePath(selectionLasso);
ds.DrawGeometry(pathGeometry, Colors.Magenta, 5.0f);
}
private void updateGlyphGeometries(ICanvasResourceCreator g, Vector2 center, Vector2 start, Vector2 end)
{
if (Math.Round(center.Angle(start, end), 3) == 90)
{
using (var pathBuilder = new CanvasPathBuilder(g))
{
var p1 = center.GetLinePoint(start, Pen.GlyphSize);
var p2 = center.GetLinePoint(end, Pen.GlyphSize);
var p3 = new Vector2(p1.X + p2.X - center.X, p1.Y + p2.Y - center.Y);
pathBuilder.BeginFigure(p1);
pathBuilder.AddLine(p3);
pathBuilder.AddLine(p2);
pathBuilder.EndFigure(CanvasFigureLoop.Open);
var geo = CanvasGeometry.CreatePath(pathBuilder);
AddGeometry(new GeometryConfig
{
Geometry = geo,
Style = GeometryStyle.Stroke,
StrokeColor = Pen.Color,
StrokeWidth = Pen.Width
});
}
}
}
protected void DrawAlarmHighArc(CanvasControl sender, CanvasDrawEventArgs args, Color alarmColor, double alarmValue)
{
var ds = args.DrawingSession;
float percentValue = (float)((alarmValue - MinValue) / (MaxValue - MinValue));
float range = GaugeEndAngle - GaugeStartAngle;
float arcStartAngle = GaugeStartAngle + (range * percentValue);
float arcSweepAngle = GaugeEndAngle - arcStartAngle;
if (arcSweepAngle > 360)
{
arcSweepAngle -= 360;
}
float startAngle = (float)(arcStartAngle * Math.PI / 180D);
float sweepAngle = (float)(arcSweepAngle * Math.PI / 180D);
double radian = arcStartAngle * Math.PI / 180D;
float startX = (float)(Math.Cos(radian) * MiddleCircleRadius) + Center.X;
float startY = (float)(Math.Sin(radian) * MiddleCircleRadius) + Center.Y;
Vector2 startPoint = new Vector2(startX, startY);
using (var builder = new CanvasPathBuilder(sender))
{
builder.BeginFigure(startPoint);
builder.AddArc(Center, MiddleCircleRadius, MiddleCircleRadius, startAngle, sweepAngle);
builder.EndFigure(CanvasFigureLoop.Open);
using (var geometry = CanvasGeometry.CreatePath(builder))
{
ds.DrawGeometry(geometry, alarmColor, (float)MediumTicLength, arcStrokeStyle);
}
}
}
public static CanvasGeometry Parse(ICanvasResourceCreator sender, IList <ClosedVectorPath> contours, float scale = 1.0f)
{
var builder = new CanvasPathBuilder(sender);
foreach (var path in contours)
{
var last = path.Commands.Last();
if (last is VectorPathCommandLine lastLine)
{
builder.BeginFigure(lastLine.EndPoint.ToVector2(scale));
}
else if (last is VectorPathCommandCubicBezierCurve lastCubicBezierCurve)
{
builder.BeginFigure(lastCubicBezierCurve.EndPoint.ToVector2(scale));
}
for (int i = 0; i < path.Commands.Count; i++)
{
var command = path.Commands[i];
if (command is VectorPathCommandLine line)
{
builder.AddLine(line.EndPoint.ToVector2(scale));
}
else if (command is VectorPathCommandCubicBezierCurve cubicBezierCurve)
{
builder.AddCubicBezier(cubicBezierCurve.StartControlPoint.ToVector2(scale),
cubicBezierCurve.EndControlPoint.ToVector2(scale),
cubicBezierCurve.EndPoint.ToVector2(scale));
}
}
builder.EndFigure(CanvasFigureLoop.Closed);
}
return(CanvasGeometry.CreatePath(builder));
}
protected override CanvasGeometry BuildBaseGeometry(ICanvasResourceCreator resourceCreator)
{
using (CanvasPathBuilder pathBuilder = new CanvasPathBuilder(resourceCreator))
{
pathBuilder.SetFilledRegionDetermination(fillRule);
if (points != null)
{
if (points.Length > 0)
{
pathBuilder.BeginFigure(points[0]);
}
for (int i = 1; i < points.Length; i++)
{
pathBuilder.AddLine(points[i]);
}
}
pathBuilder.EndFigure(CanvasFigureLoop);
return(CanvasGeometry.CreatePath(pathBuilder));
}
}
static CanvasGeometry CreateTimeSegmentGeometry(CanvasDrawingSession ds, long updateCount, double updatesPerSecond)
{
double updates = (double)updateCount;
double fractionSecond = (updates / updatesPerSecond) % 1.0;
double fractionSecondAngle = 2 * Math.PI * fractionSecond;
fractionSecondAngle *= -1; // increasing fractionSecond = clockwise = decreasing angle
fractionSecondAngle += Math.PI; // we want fractionSecond = 0 to be up (not down)
double angle = fractionSecondAngle % (2 * Math.PI);
using (var builder = new CanvasPathBuilder(ds))
{
builder.BeginFigure(new Vector2(center, center));
builder.AddLine(new Vector2(center, center - radius));
var endArcX = new Vector2(center + (float)Math.Sin(angle) * radius, center + (float)Math.Cos(angle) * radius);
var arcSize = angle > 0 ? CanvasArcSize.Small : CanvasArcSize.Large;
builder.AddArc(endArcX, radius, radius, 0, CanvasSweepDirection.Clockwise, arcSize);
builder.EndFigure(CanvasFigureLoop.Closed);
return(CanvasGeometry.CreatePath(builder));
}
}
internal static CanvasGeometry GenerateGeometry(CanvasDevice device, Size size, CompositionPathInfo info, Vector2 offset)
{
//
// |--LeftTop----------------------RightTop--|
// | |
// TopLeft TopRight
// | |
// | |
// | |
// | |
// | |
// | |
// BottomLeft BottomRight
// | |
// |--LeftBottom----------------RightBottom--|
//
// compute the coordinates of the key points
var leftTop = new Vector2(info.LeftTop.Single(), 0);
var rightTop = new Vector2((size.Width - info.RightTop).Single(), 0);
var topRight = new Vector2(size.Width.Single(), info.TopRight.Single());
var bottomRight = new Vector2(size.Width.Single(), (size.Height - info.BottomRight).Single());
var rightBottom = new Vector2((size.Width - info.RightBottom).Single(), size.Height.Single());
var leftBottom = new Vector2(info.LeftBottom.Single(), size.Height.Single());
var bottomLeft = new Vector2(0, (size.Height - info.BottomLeft).Single());
var topLeft = new Vector2(0, info.TopLeft.Single());
// check keypoints for overlap and resolve by partitioning corners according to
// the percentage of each one.
// top edge
if (leftTop.X > rightTop.X)
{
var v = ((info.LeftTop) / (info.LeftTop + info.RightTop) * size.Width).Single();
leftTop.X = v;
rightTop.X = v;
}
// right edge
if (topRight.Y > bottomRight.Y)
{
var v = ((info.TopRight) / (info.TopRight + info.BottomRight) * size.Height).Single();
topRight.Y = v;
bottomRight.Y = v;
}
// bottom edge
if (leftBottom.X > rightBottom.X)
{
var v = ((info.LeftBottom) / (info.LeftBottom + info.RightBottom) * size.Width).Single();
rightBottom.X = v;
leftBottom.X = v;
}
// left edge
if (topLeft.Y > bottomLeft.Y)
{
var v = ((info.TopLeft) / (info.TopLeft + info.BottomLeft) * size.Height).Single();
bottomLeft.Y = v;
topLeft.Y = v;
}
// Apply offset
leftTop += offset;
rightTop += offset;
topRight += offset;
bottomRight += offset;
rightBottom += offset;
leftBottom += offset;
bottomLeft += offset;
topLeft += offset;
// create the border geometry
var pathBuilder = new CanvasPathBuilder(device);
// Begin path
pathBuilder.BeginFigure(leftTop);
// Top line
pathBuilder.AddLine(rightTop);
// Upper-right corners
var radiusX = size.Width - rightTop.X;
var radiusY = (double)topRight.Y;
if (!radiusX.IsZero() || !radiusY.IsZero())
{
pathBuilder.AddArc(topRight, radiusX.Single(), radiusY.Single(), (Math.PI / 2f).Single(),
CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
}
// Right line
pathBuilder.AddLine(bottomRight);
// Lower-right corners
radiusX = size.Width - rightBottom.X;
radiusY = size.Height - bottomRight.Y;
if (!radiusX.IsZero() || !radiusY.IsZero())
{
pathBuilder.AddArc(rightBottom, radiusX.Single(), radiusY.Single(), (Math.PI / 2f).Single(),
CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
}
// Bottom line
pathBuilder.AddLine(leftBottom);
// Lower-left corners
radiusX = leftBottom.X;
radiusY = size.Height - bottomLeft.Y;
if (!radiusX.IsZero() || !radiusY.IsZero())
{
pathBuilder.AddArc(bottomLeft, radiusX.Single(), radiusY.Single(), (Math.PI / 2f).Single(),
CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
}
// Left line
pathBuilder.AddLine(topLeft);
// Upper-left corners
radiusX = leftTop.X;
radiusY = topLeft.Y;
if (!radiusX.IsZero() || !radiusY.IsZero())
{
pathBuilder.AddArc(leftTop, radiusX.Single(), radiusY.Single(), (Math.PI / 2f).Single(),
CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
}
// End path
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
return(CanvasGeometry.CreatePath(pathBuilder));
}
char _token; // Non whitespace character returned by ReadToken
public CanvasGeometry parse(string path, CanvasPathBuilder builder)
{
var _builder = builder;
//var _pathGeometry = Microsoft.Graphics.Canvas.Geometry.CanvasGeometry.CreatePath(_builder);
//_figure = _builder.BeginFigure();
////GeometrySink _sink = _pathGeometry.Open();
_formatProvider = CultureInfo.InvariantCulture;
_pathString = path;
_pathLength = path.Length;
_curIndex = 0;
_secondLastPoint = new Point(0, 0);
_lastPoint = new Point(0, 0);
_lastStart = new Point(0, 0);
_figureStarted = false;
bool first = true;
char last_cmd = ' ';
while (ReadToken()) // Empty path is allowed in XAML
{
char cmd = _token;
if (first)
{
if ((cmd != 'M') && (cmd != 'm')) // Path starts with M|m
{
ThrowBadToken();
}
first = false;
}
switch (cmd)
{
case 'm':
case 'M':
// XAML allows multiple points after M/m
_lastPoint = ReadPoint(cmd, !AllowComma);
_builder.BeginFigure((float)_lastPoint.X, (float)_lastPoint.Y, IsFilled ? CanvasFigureFill.Default : CanvasFigureFill.DoesNotAffectFills); // FigureBegin.Filled : FigureBegin.Hollow);
//_figure.StartPoint = _lastPoint;
//_figure.IsFilled = IsFilled;
//if (!IsClosed) _figure.Close();
//_figure.IsClosed = !IsClosed;
//context.BeginFigure(_lastPoint, IsFilled, !IsClosed);
_figureStarted = true;
_lastStart = _lastPoint;
last_cmd = 'M';
while (IsNumber(AllowComma))
{
_lastPoint = ReadPoint(cmd, !AllowComma);
//LineSegment _lineSegment = new LineSegment();
//_lineSegment.Point = _lastPoint;
_builder.AddLine((float)_lastPoint.X, (float)_lastPoint.Y);
//_figure.Segments.Add(_lineSegment);
//context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
last_cmd = 'L';
}
break;
case 'l':
case 'L':
case 'h':
case 'H':
case 'v':
case 'V':
EnsureFigure(_builder);
do
{
switch (cmd)
{
case 'l': _lastPoint = ReadPoint(cmd, !AllowComma); break;
case 'L': _lastPoint = ReadPoint(cmd, !AllowComma); break;
case 'h': _lastPoint.X += ReadNumber(!AllowComma); break;
case 'H': _lastPoint.X = ReadNumber(!AllowComma); break;
case 'v': _lastPoint.Y += ReadNumber(!AllowComma); break;
case 'V': _lastPoint.Y = ReadNumber(!AllowComma); break;
}
//LineSegment _lineSegment = new LineSegment();
//_lineSegment.Point = _lastPoint;
//_figure.Segments.Add(_lineSegment);
_builder.AddLine((float)_lastPoint.X, (float)_lastPoint.Y);
//context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
}
while (IsNumber(AllowComma));
last_cmd = 'L';
break;
case 'c':
case 'C': // cubic Bezier
case 's':
case 'S': // smooth cublic Bezier
EnsureFigure(_builder);
do
{
Point p;
if ((cmd == 's') || (cmd == 'S'))
{
if (last_cmd == 'C')
{
p = Reflect();
}
else
{
p = _lastPoint;
}
_secondLastPoint = ReadPoint(cmd, !AllowComma);
}
else
{
p = ReadPoint(cmd, !AllowComma);
_secondLastPoint = ReadPoint(cmd, AllowComma);
}
_lastPoint = ReadPoint(cmd, AllowComma);
//BezierSegment _bizierSegment = new BezierSegment();
//_bizierSegment.Point1 = p;
//_bizierSegment.Point2 = _secondLastPoint;
//_bizierSegment.Point3 = _lastPoint;
//_figure.Segments.Add(_bizierSegment);
_builder.AddCubicBezier(
new System.Numerics.Vector2((float)p.X, (float)p.Y),
new System.Numerics.Vector2((float)_secondLastPoint.X, (float)_secondLastPoint.Y),
new System.Numerics.Vector2((float)_lastPoint.X, (float)_lastPoint.Y)
);
//context.BezierTo(p, _secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);
last_cmd = 'C';
}
while (IsNumber(AllowComma));
break;
case 'q':
case 'Q': // quadratic Bezier
case 't':
case 'T': // smooth quadratic Bezier
EnsureFigure(_builder);
do
{
if ((cmd == 't') || (cmd == 'T'))
{
if (last_cmd == 'Q')
{
_secondLastPoint = Reflect();
}
else
{
_secondLastPoint = _lastPoint;
}
_lastPoint = ReadPoint(cmd, !AllowComma);
}
else
{
_secondLastPoint = ReadPoint(cmd, !AllowComma);
_lastPoint = ReadPoint(cmd, AllowComma);
}
//QuadraticBezierSegment _quadraticBezierSegment = new QuadraticBezierSegment();
//_quadraticBezierSegment.Point1 = _secondLastPoint;
//_quadraticBezierSegment.Point2 = _lastPoint;
//_figure.Segments.Add(_quadraticBezierSegment);
_builder.AddQuadraticBezier(
new System.Numerics.Vector2((float)_secondLastPoint.X, (float)_secondLastPoint.Y),
new System.Numerics.Vector2((float)_lastPoint.X, (float)_lastPoint.Y)
);
//context.QuadraticBezierTo(_secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);
last_cmd = 'Q';
}
while (IsNumber(AllowComma));
break;
case 'a':
case 'A':
EnsureFigure(_builder);
do
{
// A 3,4 5, 0, 0, 6,7
double w = ReadNumber(!AllowComma);
double h = ReadNumber(AllowComma);
double rotation = ReadNumber(AllowComma);
bool large = ReadBool();
bool sweep = ReadBool();
_lastPoint = ReadPoint(cmd, AllowComma);
//ArcSegment _arcSegment = new ArcSegment();
//_arcSegment.Point = _lastPoint;
//_arcSegment.Size = new Size(w, h);
//_arcSegment.RotationAngle = rotation;
//_arcSegment.IsLargeArc = large;
//_arcSegment.SweepDirection = sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise;
//_figure.Segments.Add(_arcSegment);
_builder.AddArc(
new System.Numerics.Vector2((float)_lastPoint.X, (float)_lastPoint.Y),
(float)w,
(float)h,
(float)rotation,
sweep ? CanvasSweepDirection.Clockwise : CanvasSweepDirection.CounterClockwise,
large ? CanvasArcSize.Large : CanvasArcSize.Small
);
//context.ArcTo(
// _lastPoint,
// new Size(w, h),
// rotation,
// large,
// sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise,
// IsStroked,
// !IsSmoothJoin
// );
}
while (IsNumber(AllowComma));
last_cmd = 'A';
break;
case 'z':
case 'Z':
EnsureFigure(_builder);
//_figure.IsClosed = IsClosed;
//context.SetClosedState(IsClosed);
_builder.EndFigure(IsClosed ? CanvasFigureLoop.Closed : CanvasFigureLoop.Open);
_figureStarted = false;
last_cmd = 'Z';
_lastPoint = _lastStart; // Set reference point to be first point of current figure
break;
default:
ThrowBadToken();
break;
}
}
//if (null != _figure)
//{
// _pathGeometry = new PathGeometry(d2dfactory);
// _pathGeometry.Figures.Add(_figure);
//}
//_builder.EndFigure();
//_sink.Close();
var _pathGeometry = Microsoft.Graphics.Canvas.Geometry.CanvasGeometry.CreatePath(_builder);
_builder = null;
return _pathGeometry;
}
public void Draw(CanvasDrawingSession graphics, float scale)
{
var x = X * scale;
var y = Y * scale;
var radius = 4;
var color = Color.FromArgb(200, 0xFF, 0xFF, 0xFF);
var color2 = Color.FromArgb(200, 0x00, 0x00, 0x00);
graphics.FillCircle((float)x, (float)y, radius, color);
graphics.DrawCircle((float)x, (float)y, radius, color2);
if (!_translated)
{
_translated = true;
if (TagType == 0)
{
TagText = "@" + TagText;
}
else if (TagType == 1)
{
TagText = "#" + TagText + "#";
}
else
{
//TagText = "↓" + TagText;
}
}
var ctFormat = new CanvasTextFormat {
FontSize = 11.0f * scale, WordWrapping = CanvasWordWrapping.NoWrap, FontFamily = "微软雅黑"
};
var ctLayout = new CanvasTextLayout(graphics, TagText, ctFormat, 0.0f, 0.0f);
//字体占用高度、宽度
var width = ctLayout.DrawBounds.Width + 10 * scale;
var height = ctLayout.DrawBounds.Height + 12 * scale;
var w = x + width + 10 * scale + height;
var pathBuilder = new CanvasPathBuilder(graphics);
if (w > Bound.Width * scale) //超出画布边界
{
pathBuilder.BeginFigure((float)x - 5 * scale, (float)y);
pathBuilder.AddLine((float)x - 5 * scale - 6 * scale, (float)y - (float)height / 2);
pathBuilder.AddLine((float)x - (float)width - 5 * scale - 6 * scale, (float)y - (float)height / 2);
pathBuilder.AddLine((float)x - (float)width - 5 * scale - 6 * scale, (float)y + (float)height / 2);
pathBuilder.AddLine((float)x - 5 * scale - 6 * scale, (float)y + (float)height / 2);
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
var geometry = CanvasGeometry.CreatePath(pathBuilder);
graphics.FillGeometry(geometry, color2);
graphics.DrawText(TagText, (float)x - (float)width - 5 * scale - 6 * scale + 5 * scale, (float)y - (float)height / 2 + 4 * scale, Colors.White, ctFormat);
_region = new Rect((float)x - (float)width - 5 * scale - 6 * scale, (float)y - (float)height / 2, width, height);
_close_region = new Rect((float)x - (float)width - 5 * scale - 6 * scale - height, (float)y - (float)height / 2, height, height);
if (ShowCloseBtn && scale == 1) //显示关闭按钮 且没有缩放
{
graphics.FillRectangle(_close_region, color2);
graphics.DrawLine((float)_close_region.Left, (float)_close_region.Top, (float)_close_region.Left, (float)_close_region.Top + (float)height, Colors.White, 0.5f);
graphics.DrawText("×", (float)_close_region.Left + 6, (float)_close_region.Top, Colors.White, new CanvasTextFormat()
{
FontSize = 15, FontFamily = "微软雅黑"
});
}
}
else
{
pathBuilder.BeginFigure((float)x + 5 * scale, (float)y);
pathBuilder.AddLine((float)x + 5 * scale + 6 * scale, (float)y - (float)height / 2);
pathBuilder.AddLine((float)x + (float)width + 5 * scale + 6 * scale, (float)y - (float)height / 2);
pathBuilder.AddLine((float)x + (float)width + 5 * scale + 6 * scale, (float)y + (float)height / 2);
pathBuilder.AddLine((float)x + 5 * scale + 6 + scale, (float)y + (float)height / 2);
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
var geo = CanvasGeometry.CreatePath(pathBuilder);
graphics.FillGeometry(geo, color2);
graphics.DrawText(TagText, (float)x + 5 * scale + 4 * scale + 5 * scale, (float)y - (float)height / 2 + 4 * scale, Colors.White, ctFormat);
_region = new Rect((float)x + 5 * scale + 6 * scale, (float)y - (float)height / 2, width, height);
_close_region = new Rect((float)x + (float)width + 5 * scale + 6 * scale, (float)y - (float)height / 2, height, height);
if (ShowCloseBtn && scale == 1) //显示关闭按钮 且 没有缩放
{
graphics.FillRectangle(_close_region, color2);
graphics.DrawLine((float)_close_region.Left, (float)_close_region.Top, (float)_close_region.Left, (float)_close_region.Top + (float)height, Colors.White, 0.5f);
graphics.DrawText("×", (float)_close_region.Left + 6, (float)_close_region.Top, Colors.White, new CanvasTextFormat()
{
FontSize = 15, FontFamily = "微软雅黑"
});
}
}
}
protected override void drawChart(CanvasDrawingSession canvas)
{
if (chartData == null)
{
return;
}
int transitionAlpha = 255;
//canvas.save();
if (transitionMode == TRANSITION_MODE_CHILD)
{
transitionAlpha = (int)(transitionParams.progress * transitionParams.progress * 255);
canvas.Transform = Matrix3x2.CreateScale(
new Vector2(transitionParams.progress, transitionParams.progress),
new Vector2(chartArea.centerX(), chartArea.centerY())
);
}
if (isEmpty)
{
if (emptyDataAlpha != 0)
{
emptyDataAlpha -= 0.12f;
if (emptyDataAlpha < 0)
{
emptyDataAlpha = 0;
}
invalidate();
}
}
else
{
if (emptyDataAlpha != 1f)
{
emptyDataAlpha += 0.12f;
if (emptyDataAlpha > 1f)
{
emptyDataAlpha = 1f;
}
invalidate();
}
}
transitionAlpha = (int)(transitionAlpha * emptyDataAlpha);
float sc = 0.4f + emptyDataAlpha * 0.6f;
canvas.Transform = Matrix3x2.CreateScale(
new Vector2(sc, sc),
new Vector2(chartArea.centerX(), chartArea.centerY())
);
int radius = (int)((chartArea.Width > chartArea.Height ? chartArea.Height : chartArea.Width) * 0.45f);
rectF = createRect(
chartArea.centerX() - radius,
chartArea.centerY() + 16 - radius,
chartArea.centerX() + radius,
chartArea.centerY() + 16 + radius
);
float a = -90f;
float rText;
int n = lines.Count;
float localSum = 0f;
for (int i = 0; i < n; i++)
{
float v = lines[i].drawingPart * lines[i].alpha;
localSum += v;
}
if (localSum == 0)
{
//canvas.restore();
return;
}
for (int i = 0; i < n; i++)
{
if (lines[i].alpha <= 0 && !lines[i].enabled)
{
continue;
}
lines[i].paint.A = (byte)transitionAlpha;
float currentPercent = lines[i].drawingPart / localSum * lines[i].alpha;
darawingValuesPercentage[i] = currentPercent;
if (currentPercent == 0)
{
continue;
}
//canvas.save();
double textAngle = a + (currentPercent / 2f) * 360f;
if (lines[i].selectionA > 0f)
{
float ai = INTERPOLATOR.getInterpolation(lines[i].selectionA);
canvas.Transform = Matrix3x2.CreateTranslation(
(float)(Math.Cos(MathEx.ToRadians(textAngle)) * 8 * ai),
(float)(Math.Sin(MathEx.ToRadians(textAngle)) * 8 * ai)
);
}
//lines[i].paint.setStyle(Paint.Style.FILL_AND_STROKE);
lines[i].paint.StrokeWidth = 1;
//lines[i].paint.setAntiAlias(!USE_LINES);
//canvas.drawArc(
// rectF,
// a,
// (currentPercent) * 360f,
// true,
// lines[i].paint);
var b = a + (currentPercent) * 360f;
var builder = new CanvasPathBuilder(canvas);
var center = new Vector2((float)rectF.X + (float)rectF.Width / 2, (float)rectF.Y + (float)rectF.Height / 2);
builder.BeginFigure(center);
builder.AddLine(
new Vector2(
(float)(center.X + Math.Sin(a * Math.PI / 180) * (float)rectF.Width / 2),
(float)(center.Y - Math.Cos(a * Math.PI / 180) * (float)rectF.Height / 2)));
builder.AddArc(
new Vector2(
(float)(center.X + Math.Sin(b * Math.PI / 180) * (float)rectF.Width / 2),
(float)(center.Y - Math.Cos(b * Math.PI / 180) * (float)rectF.Height / 2)),
(float)rectF.Width / 2,
(float)rectF.Height / 2,
0, CanvasSweepDirection.Clockwise,
(b - a) >= 180.0 ? CanvasArcSize.Large : CanvasArcSize.Small);
builder.EndFigure(CanvasFigureLoop.Closed);
canvas.FillGeometry(CanvasGeometry.CreatePath(builder), lines[i].paint.Color);
//lines[i].paint.setStyle(Paint.Style.STROKE);
//canvas.restore();
canvas.Transform = Matrix3x2.Identity;
lines[i].paint.A = 255;
a += currentPercent * 360f;
}
a = -90f;
for (int i = 0; i < n; i++)
{
if (lines[i].alpha <= 0 && !lines[i].enabled)
{
continue;
}
float currentPercent = (lines[i].drawingPart * lines[i].alpha / localSum);
//canvas.save();
double textAngle = a + (currentPercent / 2f) * 360f;
if (lines[i].selectionA > 0f)
{
float ai = INTERPOLATOR.getInterpolation(lines[i].selectionA);
canvas.Transform = Matrix3x2.CreateTranslation(
(float)(Math.Cos(MathEx.ToRadians(textAngle)) * 8 * ai),
(float)(Math.Sin(MathEx.ToRadians(textAngle)) * 8 * ai)
);
}
int percent = (int)(100f * currentPercent);
if (currentPercent >= 0.02f && percent > 0 && percent <= 100)
{
rText = (float)(rectF.Width * 0.42f * Math.Sqrt(1f - currentPercent));
//textPaint.setTextSize(MIN_TEXT_SIZE + currentPercent * MAX_TEXT_SIZE);
//textPaint.setAlpha((int)(transitionAlpha * lines[i].alpha));
//canvas.DrawText(
// lookupTable[percent],
// (float)(rectF.centerX() + rText * Math.Cos(MathEx.ToRadians(textAngle))),
// (float)(rectF.centerY() + rText * Math.Sin(MathEx.ToRadians(textAngle))) - ((textPaint.descent() + textPaint.ascent()) / 2),
// textPaint);
}
//canvas.restore();
canvas.Transform = Matrix3x2.Identity;
lines[i].paint.A = 255;
a += currentPercent * 360f;
}
//canvas.restore();
canvas.Transform = Matrix3x2.Identity;
}
internal override void fillPath(CanvasPathBuilder p)
{
pendingRenderingOperations.Add(new FillPathPainter(clip, color, alpha, p));
}
public static CanvasGeometry ToCanvasGeometry(this XPathGeometry pg, CanvasDrawingSession ds)
{
CanvasGeometry g;
using (var builder = new CanvasPathBuilder(ds))
{
if (pg.FillRule == XFillRule.EvenOdd)
{
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Alternate);
}
else
{
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Winding);
}
foreach (var pf in pg.Figures)
{
builder.BeginFigure(
(float)pf.StartPoint.X,
(float)pf.StartPoint.Y,
pf.IsFilled ? CanvasFigureFill.Default : CanvasFigureFill.DoesNotAffectFills);
foreach (var segment in pf.Segments)
{
var options = CanvasFigureSegmentOptions.None;
if (!segment.IsStroked)
{
options |= CanvasFigureSegmentOptions.ForceUnstroked;
}
if (segment.IsSmoothJoin)
{
options |= CanvasFigureSegmentOptions.ForceRoundLineJoin;
}
builder.SetSegmentOptions(options);
if (segment is XArcSegment)
{
var arcSegment = segment as XArcSegment;
builder.AddArc(
new N.Vector2(
(float)arcSegment.Point.X,
(float)arcSegment.Point.Y),
(float)(arcSegment.Size.Width / 2.0),
(float)(arcSegment.Size.Height / 2.0),
(float)arcSegment.RotationAngle,
arcSegment.SweepDirection == XSweepDirection.Clockwise ? CanvasSweepDirection.Clockwise : CanvasSweepDirection.CounterClockwise,
arcSegment.IsLargeArc ? CanvasArcSize.Large : CanvasArcSize.Small);
}
else if (segment is XBezierSegment)
{
var bezierSegment = segment as XBezierSegment;
builder.AddCubicBezier(
new N.Vector2(
(float)bezierSegment.Point1.X,
(float)bezierSegment.Point1.Y),
new N.Vector2(
(float)bezierSegment.Point2.X,
(float)bezierSegment.Point2.Y),
new N.Vector2(
(float)bezierSegment.Point3.X,
(float)bezierSegment.Point3.Y));
}
else if (segment is XLineSegment)
{
var lineSegment = segment as XLineSegment;
builder.AddLine(
new N.Vector2(
(float)lineSegment.Point.X,
(float)lineSegment.Point.Y));
}
else if (segment is XPolyBezierSegment)
{
var polyBezierSegment = segment as XPolyBezierSegment;
if (polyBezierSegment.Points.Count >= 3)
{
builder.AddCubicBezier(
new N.Vector2(
(float)polyBezierSegment.Points[0].X,
(float)polyBezierSegment.Points[0].Y),
new N.Vector2(
(float)polyBezierSegment.Points[1].X,
(float)polyBezierSegment.Points[1].Y),
new N.Vector2(
(float)polyBezierSegment.Points[2].X,
(float)polyBezierSegment.Points[2].Y));
}
if (polyBezierSegment.Points.Count > 3 &&
polyBezierSegment.Points.Count % 3 == 0)
{
for (int i = 3; i < polyBezierSegment.Points.Count; i += 3)
{
builder.AddCubicBezier(
new N.Vector2(
(float)polyBezierSegment.Points[i].X,
(float)polyBezierSegment.Points[i].Y),
new N.Vector2(
(float)polyBezierSegment.Points[i + 1].X,
(float)polyBezierSegment.Points[i + 1].Y),
new N.Vector2(
(float)polyBezierSegment.Points[i + 2].X,
(float)polyBezierSegment.Points[i + 2].Y));
}
}
}
else if (segment is XPolyLineSegment)
{
var polyLineSegment = segment as XPolyLineSegment;
if (polyLineSegment.Points.Count >= 1)
{
builder.AddLine(
new N.Vector2(
(float)polyLineSegment.Points[0].X,
(float)polyLineSegment.Points[0].Y));
}
if (polyLineSegment.Points.Count > 1)
{
for (int i = 1; i < polyLineSegment.Points.Count; i++)
{
builder.AddLine(
new N.Vector2(
(float)polyLineSegment.Points[i].X,
(float)polyLineSegment.Points[i].Y));
}
}
}
else if (segment is XPolyQuadraticBezierSegment)
{
var polyQuadraticSegment = segment as XPolyQuadraticBezierSegment;
if (polyQuadraticSegment.Points.Count >= 2)
{
builder.AddQuadraticBezier(
new N.Vector2(
(float)polyQuadraticSegment.Points[0].X,
(float)polyQuadraticSegment.Points[0].Y),
new N.Vector2(
(float)polyQuadraticSegment.Points[1].X,
(float)polyQuadraticSegment.Points[1].Y));
}
if (polyQuadraticSegment.Points.Count > 2 &&
polyQuadraticSegment.Points.Count % 2 == 0)
{
for (int i = 3; i < polyQuadraticSegment.Points.Count; i += 3)
{
builder.AddQuadraticBezier(
new N.Vector2(
(float)polyQuadraticSegment.Points[i].X,
(float)polyQuadraticSegment.Points[i].Y),
new N.Vector2(
(float)polyQuadraticSegment.Points[i + 1].X,
(float)polyQuadraticSegment.Points[i + 1].Y));
}
}
}
else if (segment is XQuadraticBezierSegment)
{
var qbezierSegment = segment as XQuadraticBezierSegment;
builder.AddQuadraticBezier(
new N.Vector2(
(float)qbezierSegment.Point1.X,
(float)qbezierSegment.Point1.Y),
new N.Vector2(
(float)qbezierSegment.Point2.X,
(float)qbezierSegment.Point2.Y));
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
builder.EndFigure(pf.IsClosed ? CanvasFigureLoop.Closed : CanvasFigureLoop.Open);
}
g = CanvasGeometry.CreatePath(builder);
}
return(g);
}
public static void AddOneLineFigure(this CanvasPathBuilder builder, float x1, float y1, float x2, float y2)
{
builder.BeginFigure(x1, y1);
builder.AddLine(x2, y2);
builder.EndFigure(CanvasFigureLoop.Open);
}
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args)
{
var ds = args.DrawingSession;
var centerPoint = (arcPoints[0] + arcPoints[1]) / 2;
// Draw the end point markers.
if (!ThumbnailGenerator.IsDrawingThumbnail)
{
for (int i = 0; i < 2; i++)
{
ds.DrawCircle(arcPoints[i], hitTestRadius, (i == activeDrag) ? Colors.White : Colors.Gray);
}
}
switch (CurrentOverload)
{
case AddArcOverload.AroundEllipse:
// Compute positions.
var ellipseRadius = (arcPoints[1] - arcPoints[0]) / 2;
ellipseRadius.X = Math.Abs(ellipseRadius.X);
ellipseRadius.Y = Math.Abs(ellipseRadius.Y);
float startAngle = Utils.DegreesToRadians(ArcStartAngle);
float sweepAngle = Utils.DegreesToRadians(ArcSweepAngle);
var startPoint = centerPoint + Vector2.Transform(Vector2.UnitX, Matrix3x2.CreateRotation(startAngle)) * ellipseRadius;
// Draw the bounding rectangle.
if (!ThumbnailGenerator.IsDrawingThumbnail)
{
ds.DrawRectangle(new Rect(arcPoints[0].ToPoint(), arcPoints[1].ToPoint()), Color.FromArgb(255, 64, 64, 64));
}
// Draw the arc.
using (var builder = new CanvasPathBuilder(sender))
{
builder.BeginFigure(startPoint);
builder.AddArc(centerPoint, ellipseRadius.X, ellipseRadius.Y, startAngle, sweepAngle);
builder.EndFigure(CanvasFigureLoop.Open);
using (var geometry = CanvasGeometry.CreatePath(builder))
{
ds.DrawGeometry(geometry, Colors.Yellow, strokeWidth, strokeStyle);
}
}
break;
case AddArcOverload.PointToPoint:
// Display a warning if this is an invalid arc configuration.
bool isRadiusTooSmall = IsArcRadiusTooSmall();
if (isRadiusTooSmall)
{
ds.DrawText("Radius is less than the\ndistance between the\nstart and end points", centerPoint, Colors.Red, textFormat);
}
// Draw the arc.
using (var builder = new CanvasPathBuilder(sender))
{
builder.BeginFigure(arcPoints[0]);
builder.AddArc(arcPoints[1], ArcRadiusX, ArcRadiusY, Utils.DegreesToRadians(ArcRotation), ArcSweepDirection, ArcSize);
builder.EndFigure(CanvasFigureLoop.Open);
using (var geometry = CanvasGeometry.CreatePath(builder))
{
ds.DrawGeometry(geometry, isRadiusTooSmall ? Colors.Red : Colors.Yellow, strokeWidth, strokeStyle);
}
}
break;
}
}
CanvasGeometry MakeConvexGeometry()
{
if (currentPointsInContact.Count == 0)
return null;
var hull = ConvexHull.Create(currentPointsInContact.Values.Select(x => x.ToVector2()));
// Figure out where the center is
var hullCenter = Vector2.Zero;
foreach (var p in hull)
{
hullCenter += p;
}
hullCenter /= hull.Count;
// Build the geometry, made up of arcs around the hull
using (var builder = new CanvasPathBuilder(device))
{
builder.BeginFigure(hull[0]);
for (int i = 1; i <= hull.Count; ++i)
{
//
// i-2 --- i-1 --- i --- i+1
// a --- b --- c --- d
//
// The bezier is between i-1 and i. We need to figure out the control points
// that make this smooth.
var a = hull[(i + hull.Count - 2) % hull.Count];
var b = hull[(i + hull.Count - 1) % hull.Count];
var c = hull[i % hull.Count];
var d = hull[(i + 1) % hull.Count];
var ab = Vector2.Normalize(b - a);
var bc = Vector2.Normalize(c - b);
var cp1 = b + Vector2.Normalize(ab + bc) * (c - b).Length() * 0.5f;
var cd = Vector2.Normalize(d - c);
var cp2 = c - Vector2.Normalize(bc + cd) * (c - b).Length() * 0.5f;
builder.AddCubicBezier(cp1, cp2, c);
}
builder.EndFigure(CanvasFigureLoop.Closed);
return CanvasGeometry.CreatePath(builder);
}
}
public void Draw(object ds, XArc arc, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var a = WpfArc.FromXArc(arc, dx, dy);
var _ds = ds as CanvasDrawingSession;
double thickness = arc.Style.Thickness / _state.Zoom;
var brush = ToColor(arc.Style.Fill);
var pen = ToColor(arc.Style.Stroke);
var ss = CreateStrokeStyle(arc.Style);
CanvasGeometry g;
using (var builder = new CanvasPathBuilder(_ds))
{
builder.BeginFigure((float)a.Start.X, (float)a.Start.Y);
builder.AddArc(
new N.Vector2(
(float)a.End.X,
(float)a.End.Y),
(float)a.Radius.Width,
(float)a.Radius.Height,
0f,
CanvasSweepDirection.Clockwise,
a.IsLargeArc ? CanvasArcSize.Large : CanvasArcSize.Small);
builder.EndFigure(CanvasFigureLoop.Open);
g = CanvasGeometry.CreatePath(builder);
}
if (arc.IsFilled)
{
_ds.FillGeometry(g, brush);
}
if (arc.IsStroked)
{
_ds.DrawGeometry(g, pen, (float)thickness, ss);
}
g.Dispose();
ss.Dispose();
}
internal static CanvasGeometry GenerateGeometry(CanvasDevice device, Size size, CompositionPathInfo info, Vector2 offset)
{
//
// |--LeftTop----------------------RightTop--|
// | |
// TopLeft TopRight
// | |
// | |
// | |
// | |
// | |
// | |
// BottomLeft BottomRight
// | |
// |--LeftBottom----------------RightBottom--|
//
// compute the coordinates of the key points
var leftTop = new Vector2(info.LeftTop.Single(), 0);
var rightTop = new Vector2((size.Width - info.RightTop).Single(), 0);
var topRight = new Vector2(size.Width.Single(), info.TopRight.Single());
var bottomRight = new Vector2(size.Width.Single(), (size.Height - info.BottomRight).Single());
var rightBottom = new Vector2((size.Width - info.RightBottom).Single(), size.Height.Single());
var leftBottom = new Vector2(info.LeftBottom.Single(), size.Height.Single());
var bottomLeft = new Vector2(0, (size.Height - info.BottomLeft).Single());
var topLeft = new Vector2(0, info.TopLeft.Single());
// check keypoints for overlap and resolve by partitioning corners according to
// the percentage of each one.
// top edge
if (leftTop.X > rightTop.X)
{
var v = ((info.LeftTop) / (info.LeftTop + info.RightTop) * size.Width).Single();
leftTop.X = v;
rightTop.X = v;
}
// right edge
if (topRight.Y > bottomRight.Y)
{
var v = ((info.TopRight) / (info.TopRight + info.BottomRight) * size.Height).Single();
topRight.Y = v;
bottomRight.Y = v;
}
// bottom edge
if (leftBottom.X > rightBottom.X)
{
var v = ((info.LeftBottom) / (info.LeftBottom + info.RightBottom) * size.Width).Single();
rightBottom.X = v;
leftBottom.X = v;
}
// left edge
if (topLeft.Y > bottomLeft.Y)
{
var v = ((info.TopLeft) / (info.TopLeft + info.BottomLeft) * size.Height).Single();
bottomLeft.Y = v;
topLeft.Y = v;
}
// Apply offset
leftTop += offset;
rightTop += offset;
topRight += offset;
bottomRight += offset;
rightBottom += offset;
leftBottom += offset;
bottomLeft += offset;
topLeft += offset;
// create the border geometry
var pathBuilder = new CanvasPathBuilder(device);
// Begin path
pathBuilder.BeginFigure(leftTop);
// Top line
pathBuilder.AddLine(rightTop);
// Upper-right corners
var radiusX = size.Width - rightTop.X;
var radiusY = (double)topRight.Y;
if (!radiusX.IsZero() || !radiusY.IsZero())
{
pathBuilder.AddArc(topRight, radiusX.Single(), radiusY.Single(), (Math.PI / 2f).Single(),
CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
}
// Right line
pathBuilder.AddLine(bottomRight);
// Lower-right corners
radiusX = size.Width - rightBottom.X;
radiusY = size.Height - bottomRight.Y;
if (!radiusX.IsZero() || !radiusY.IsZero())
{
pathBuilder.AddArc(rightBottom, radiusX.Single(), radiusY.Single(), (Math.PI / 2f).Single(),
CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
}
// Bottom line
pathBuilder.AddLine(leftBottom);
// Lower-left corners
radiusX = leftBottom.X;
radiusY = size.Height - bottomLeft.Y;
if (!radiusX.IsZero() || !radiusY.IsZero())
{
pathBuilder.AddArc(bottomLeft, radiusX.Single(), radiusY.Single(), (Math.PI / 2f).Single(),
CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
}
// Left line
pathBuilder.AddLine(topLeft);
// Upper-left corners
radiusX = leftTop.X;
radiusY = topLeft.Y;
if (!radiusX.IsZero() || !radiusY.IsZero())
{
pathBuilder.AddArc(leftTop, radiusX.Single(), radiusY.Single(), (Math.PI / 2f).Single(),
CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
}
// End path
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
return CanvasGeometry.CreatePath(pathBuilder);
}
void canvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args)
{
CanvasTextFormat centeredTextFormat = new CanvasTextFormat();
centeredTextFormat.HorizontalAlignment = CanvasHorizontalAlignment.Center;
centeredTextFormat.VerticalAlignment = CanvasVerticalAlignment.Center;
centeredTextFormat.FontSize = 30;
if (photoCanvasBitmap != null)
{
CanvasRenderTarget tempRenderTarget = new CanvasRenderTarget(sender, photoCanvasBitmap.Size);
using (CanvasDrawingSession ds = tempRenderTarget.CreateDrawingSession())
{
// Begin by drawing the captured photo into the temporary render target
ds.DrawImage(photoCanvasBitmap, new System.Numerics.Vector2(0, 0));
foreach (Face face in lastCapturedFaces)
{
Rect faceRect = new Rect(face.FaceRectangle.Left, face.FaceRectangle.Top, face.FaceRectangle.Width, face.FaceRectangle.Height);
ds.DrawRectangle(faceRect, Colors.Red);
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(sender);
Vector2 startingPoint = new Vector2((float)(faceRect.Left + faceRect.Width / 2), (float)faceRect.Top);
pathBuilder.BeginFigure(startingPoint);
pathBuilder.AddLine(startingPoint - new Vector2(Math.Max(70.0f, (float)faceRect.Width / 2), 10));
pathBuilder.AddLine(startingPoint - new Vector2(Math.Max(70.0f, (float)faceRect.Width / 2), 50));
pathBuilder.AddLine(startingPoint + new Vector2(Math.Max(70.0f, (float)faceRect.Width / 2), - 50));
pathBuilder.AddLine(startingPoint + new Vector2(Math.Max(70.0f, (float)faceRect.Width / 2), - 10));
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
// Draw the speech bubble above the face
CanvasGeometry geometry = CanvasGeometry.CreatePath(pathBuilder);
ds.FillGeometry(geometry, Colors.Yellow);
// Draw the person's age and gender above the face
String descString = face.Attributes.Gender.ToString() + ", " + face.Attributes.Age.ToString();
ds.DrawText(descString, startingPoint - new Vector2(0, 30), Colors.Orange, centeredTextFormat);
}
}
// End by drawing the rendertarget into the center of the screen
double imageScale = Math.Min(sender.RenderSize.Width / photoCanvasBitmap.Size.Width, sender.RenderSize.Height / tempRenderTarget.Size.Height);
double newWidth = imageScale * tempRenderTarget.Size.Width;
double newHeight = imageScale * tempRenderTarget.Size.Height;
Rect targetRect = new Rect((sender.RenderSize.Width - newWidth) / 2, (sender.RenderSize.Height - newHeight) / 2, newWidth, newHeight);
args.DrawingSession.DrawImage(tempRenderTarget, targetRect);
}
else
{
args.DrawingSession.DrawText("Processing...", (float)(sender.Size.Width / 2), (float)(sender.Size.Height / 2), Colors.White, centeredTextFormat);
}
}
private CanvasGeometry CreateGeometry(ICanvasResourceCreator resourceCreator, GeometryType type)
{
switch (type)
{
case GeometryType.Rectangle: return CanvasGeometry.CreateRectangle(resourceCreator, 100, 100, 300, 350);
case GeometryType.RoundedRectangle: return CanvasGeometry.CreateRoundedRectangle(resourceCreator, 80, 80, 400, 400, 100, 100);
case GeometryType.Ellipse: return CanvasGeometry.CreateEllipse(resourceCreator, 275, 275, 225, 275);
case GeometryType.Star:
{
return Utils.CreateStarGeometry(resourceCreator, 250, new Vector2(250, 250));
}
case GeometryType.Group:
{
CanvasGeometry geo0 = CanvasGeometry.CreateRectangle(resourceCreator, 100, 100, 100, 100);
CanvasGeometry geo1 = CanvasGeometry.CreateRoundedRectangle(resourceCreator, 300, 100, 100, 100, 50, 50);
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(resourceCreator);
pathBuilder.BeginFigure(200, 200);
pathBuilder.AddLine(500, 200);
pathBuilder.AddLine(200, 350);
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
CanvasGeometry geo2 = CanvasGeometry.CreatePath(pathBuilder);
return CanvasGeometry.CreateGroup(resourceCreator, new CanvasGeometry[] { geo0, geo1, geo2 });
}
}
System.Diagnostics.Debug.Assert(false);
return null;
}
public void AddPathSegment(CanvasPathBuilder canvasPathBuilder, ref bool closed)
{
canvasPathBuilder.AddLine(_points[0], _points[1]);
closed = false;
}
private static void renderPath(IList <PathSegment> segments, CanvasPathBuilder builder)
{
Vector2?currentPoint = null;
Vector2?cubicPoint = null;
Vector2?quadrPoint = null;
Vector2?initialPoint = null;
void M(float x, float y)
{
var point = new Vector2(x, y);
builder.BeginFigure(point);
//context.move(to: point);
setInitPoint(point);
}
void m(float x, float y)
{
if (currentPoint is Vector2 cur)
{
var next = new Vector2(x + cur.X, y + cur.Y);
builder.BeginFigure(next);
//context.move(to: next);
setInitPoint(next);
}
else
{
M(x, y: y);
}
}
void L(float x, float y)
{
lineTo(new Vector2(x, y));
}
void l(float x, float y)
{
if (currentPoint is Vector2 cur)
{
lineTo(new Vector2(x + cur.X, y + cur.Y));
}
else
{
L(x, y: y);
}
}
void H(float x)
{
if (currentPoint is Vector2 cur)
{
lineTo(new Vector2(x, cur.Y));
}
}
void h(float x)
{
if (currentPoint is Vector2 cur)
{
lineTo(new Vector2(x + cur.X, cur.Y));
}
}
void V(float y)
{
if (currentPoint is Vector2 cur)
{
lineTo(new Vector2(cur.X, y));
}
}
void v(float y)
{
if (currentPoint is Vector2 cur)
{
lineTo(new Vector2(cur.X, y + cur.Y));
}
}
void lineTo(Vector2 p)
{
builder.AddLine(p);
//context.addLine(to: p);
setPoint(p);
}
void c(float x1, float y1, float x2, float y2, float x, float y)
{
if (currentPoint is Vector2 cur)
{
var endPoint = new Vector2(x + cur.X, y + cur.Y);
var controlPoint1 = new Vector2(x1 + cur.X, y1 + cur.Y);
var controlPoint2 = new Vector2(x2 + cur.X, y2 + cur.Y);
builder.AddCubicBezier(controlPoint1, controlPoint2, endPoint);
//context.addCurve(to: endPoint, control1: controlPoint1, control2: controlPoint2);
setCubicPoint(endPoint, cubic: controlPoint2);
}
}
void C(float x1, float y1, float x2, float y2, float x, float y)
{
var endPoint = new Vector2(x, y);
var controlPoint1 = new Vector2(x1, y1);
var controlPoint2 = new Vector2(x2, y2);
builder.AddCubicBezier(controlPoint1, controlPoint2, endPoint);
//context.addCurve(to: endPoint, control1: controlPoint1, control2: controlPoint2);
setCubicPoint(endPoint, cubic: controlPoint2);
}
void s(float x2, float y2, float x, float y)
{
if (currentPoint is Vector2 cur)
{
var nextCubic = new Vector2(x2 + cur.X, y2 + cur.Y);
var next = new Vector2(x + cur.X, y + cur.Y);
Vector2 xy1;
if (cubicPoint is Vector2 curCubicVal)
{
xy1 = new Vector2((2 * cur.X) - curCubicVal.X, (2 * cur.Y) - curCubicVal.Y);
}
else
{
xy1 = cur;
}
builder.AddCubicBezier(xy1, nextCubic, next);
//context.addCurve(to: next, control1: xy1, control2: nextCubic);
setCubicPoint(next, cubic: nextCubic);
}
}
void S(float x2, float y2, float x, float y)
{
if (currentPoint is Vector2 cur)
{
var nextCubic = new Vector2(x2, y2);
var next = new Vector2(x, y);
Vector2 xy1;
if (cubicPoint is Vector2 curCubicVal)
{
xy1 = new Vector2((2 * cur.X) - curCubicVal.X, (2 * cur.Y) - curCubicVal.Y);
}
else
{
xy1 = cur;
}
builder.AddCubicBezier(xy1, nextCubic, next);
//context.addCurve(to: next, control1: xy1, control2: nextCubic);
setCubicPoint(next, cubic: nextCubic);
}
}
void z()
{
builder.EndFigure(CanvasFigureLoop.Closed);
//context.fillPath();
}
void setQuadrPoint(Vector2 p, Vector2 quadr)
{
currentPoint = p;
quadrPoint = quadr;
cubicPoint = null;
}
void setCubicPoint(Vector2 p, Vector2 cubic)
{
currentPoint = p;
cubicPoint = cubic;
quadrPoint = null;
}
void setInitPoint(Vector2 p)
{
setPoint(p);
initialPoint = p;
}
void setPoint(Vector2 p)
{
currentPoint = p;
cubicPoint = null;
quadrPoint = null;
}
foreach (var segment in segments)
{
var data = segment.data.AsSpan();
switch (segment.type)
{
case PathSegment.SegmentType.M:
M(data[0], data[1]);
data = data.Slice(2);
//data.removeSubrange(Range(uncheckedBounds: (lower: 0, upper: 2)));
while (data.Length >= 2)
{
L(data[0], data[1]);
data = data.Slice(2);
//data.removeSubrange((0.. < 2));
}
break;
case PathSegment.SegmentType.m:
m(data[0], data[1]);
data = data.Slice(2);
//data.removeSubrange((0.. < 2));
while (data.Length >= 2)
{
l(data[0], data[1]);
data = data.Slice(2);
//data.removeSubrange((0.. < 2));
}
break;
case PathSegment.SegmentType.L:
while (data.Length >= 2)
{
L(data[0], data[1]);
data = data.Slice(2);
//data.removeSubrange((0.. < 2));
}
break;
case PathSegment.SegmentType.l:
while (data.Length >= 2)
{
l(data[0], data[1]);
data = data.Slice(2);
//data.removeSubrange((0.. < 2));
}
break;
case PathSegment.SegmentType.H:
H(data[0]);
break;
case PathSegment.SegmentType.h:
h(data[0]);
break;
case PathSegment.SegmentType.V:
V(data[0]);
break;
case PathSegment.SegmentType.v:
v(data[0]);
break;
case PathSegment.SegmentType.C:
while (data.Length >= 6)
{
C(data[0], data[1], data[2], data[3], data[4], data[5]);
data = data.Slice(6);
//data.removeSubrange((0.. < 6));
}
break;
case PathSegment.SegmentType.c:
while (data.Length >= 6)
{
c(data[0], data[1], data[2], data[3], data[4], data[5]);
data = data.Slice(6);
//data.removeSubrange((0.. < 6));
}
break;
case PathSegment.SegmentType.S:
while (data.Length >= 4)
{
S(data[0], data[1], data[2], data[3]);
data = data.Slice(4);
//data.removeSubrange((0.. < 4));
}
break;
case PathSegment.SegmentType.s:
while (data.Length >= 4)
{
s(data[0], y2: data[1], x: data[2], y: data[3]);
data = data.Slice(4);
//data.removeSubrange((0.. < 4));
}
break;
case PathSegment.SegmentType.z:
z();
break;
default:
//print("unknown");
break;
}
}
}
CanvasGeometry MakeDirectionIcon(ICanvasResourceCreator creator)
{
var builder = new CanvasPathBuilder(creator);
float radius = 3;
float lineWidth = 20;
builder.BeginFigure(0, 0);
builder.AddLine(0, radius * 2);
builder.EndFigure(CanvasFigureLoop.Open);
float y = radius;
builder.BeginFigure(0, y);
builder.AddArc(new Vector2(lineWidth + radius, y + radius), radius, radius, -(float)Math.PI/2, (float)Math.PI);
y += radius * 2;
builder.AddArc(new Vector2(radius, y + radius), radius, radius, -(float)Math.PI/2, -(float)Math.PI);
y += radius * 2;
float x = lineWidth * 2 / 3;
builder.AddLine(x, y);
builder.EndFigure(CanvasFigureLoop.Open);
builder.BeginFigure(x - radius, y - radius/3);
builder.AddLine(x, y);
builder.AddLine(x - radius, y + radius/3);
builder.EndFigure(CanvasFigureLoop.Open);
return CanvasGeometry.CreatePath(builder);
}
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args)
{
if (ItemTemplate == null)
{
return;
}
if (ItemsSource == null)
{
return;
}
var repairedItemsSource = ItemsSource.Cast <ChartDataItem>().Where(item => item.Part > 0.01).ToList();
var newSum = repairedItemsSource.Sum(i => i.Value);
foreach (var item in repairedItemsSource)
{
item.Part = item.Value / newSum;
}
var d = 0d;
foreach (var item in repairedItemsSource)
{
var chartItem = (DoughnutChartItem)ItemTemplate.LoadContent();
if (chartItem == null)
{
return;
}
chartItem.DataContext = item;
if (chartItem.Color == default(Color))
{
chartItem.Color = DefaultColors.GetRandom();
}
var sweepAngle = chartItem.Angle;
var startAngle = (float)(d - Math.PI / 2);
d += sweepAngle;
var center = new Vector2((float)(ActualWidth / 2), (float)(ActualHeight / 2));
var radius = center.X > center.Y
? new Vector2(center.Y)
: new Vector2(center.X);
var startPoint = center + Vector2.Transform(Vector2.UnitX, Matrix3x2.CreateRotation(startAngle)) * radius;
var relativeDistance = Distance / radius.X;
var relativeSecondDistance = Distance / (radius.X - Thickness / 2);
var repairSweepAngle = sweepAngle > relativeDistance ? sweepAngle - relativeDistance : 0;
var repairSecondSweepAngle = sweepAngle > relativeSecondDistance / 2 ? sweepAngle - relativeSecondDistance / 2 : 0;
using (var builder = new CanvasPathBuilder(canvas)) {
builder.BeginFigure(startPoint);
builder.AddArc(center, radius.X, radius.Y, (float)(startAngle + relativeDistance / 2), (float)repairSweepAngle);
builder.AddArc(center, radius.X - (float)Thickness / 2, (float)(radius.Y - Thickness / 2), (float)(startAngle + sweepAngle - relativeSecondDistance / 2), -(float)repairSecondSweepAngle);
builder.EndFigure(CanvasFigureLoop.Closed);
args.DrawingSession.FillGeometry(
CanvasGeometry.CreatePath(builder),
chartItem.Color);
}
}
}
public void closePath()
{
if (this.pathBuilder != null) {
this.pathBuilder.Dispose();
this.pathBuilder = null;
}
}
private static CanvasGeometry CreateHeart(ICanvasResourceCreator resourceCreator, float scale, Vector2 center)
{
center = center - new Vector2(center.X / 2, center.Y / 2);
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(resourceCreator);
var begin = new Vector2(0.47f, 0.34f) * scale + center;
pathBuilder.BeginFigure(begin);
pathBuilder.AddCubicBezier(new Vector2(0.66f, 0.19f) * scale + center, new Vector2(0.88f, 0.30f) * scale + center, new Vector2(0.88f, 0.48f) * scale + center);
pathBuilder.AddCubicBezier(new Vector2(0.88f, 0.66f) * scale + center, new Vector2(0.49f, 1) * scale + center, new Vector2(0.49f, 1)* scale + center);
pathBuilder.AddCubicBezier(new Vector2(0.49f, 1) * scale + center, new Vector2(0, 0.66f) * scale + center, new Vector2(0, 0.48f) * scale + center);
pathBuilder.AddCubicBezier(new Vector2(0, 0.30f) * scale + center, new Vector2(0.33f, 0.19f) * scale + center, begin);
pathBuilder.SetSegmentOptions(CanvasFigureSegmentOptions.ForceRoundLineJoin);
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
var geometry = CanvasGeometry.CreatePath(pathBuilder);
return geometry;
}
internal virtual void drawPath(CanvasPathBuilder p, Stroke stroke)
{
graphics.DrawGeometry(CanvasGeometry.CreatePath(p), c, stroke.getLineWidth());
}
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args)
{
var ds = args.DrawingSession;
foreach (var link in Links)
{
var centerPoint = (link.Node1.Position + link.Node2.Position) / 2;
//if (Math.Abs(link.Node1.PositionX - link.Node2.PositionX) > Math.Abs(link.Node1.PositionY - link.Node2.PositionY))
//{
// ds.DrawText(link.Weight.ToString(), centerPoint.X, centerPoint.Y - 10, foregroundColor);
//}
ds.DrawEllipse((float)Canvas.ActualWidth / 2, (float)Canvas.ActualHeight / 2, 500, 500, foregroundColor);
using (var builder = new CanvasPathBuilder(sender))
{
builder.BeginFigure(link.Node1.Position);
builder.AddArc(link.Node2.Position, arcRadiusX, arcRadiusY, 0, CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
builder.EndFigure(CanvasFigureLoop.Open);
using (var geometry = CanvasGeometry.CreatePath(builder))
{
ds.DrawGeometry(geometry, foregroundColor, strokeWidth);
}
}
}
foreach (var node in Nodes)
{
DrawNode(ds, node);
}
}
internal virtual void fillPath(CanvasPathBuilder p)
{
graphics.DrawGeometry(CanvasGeometry.CreatePath(p), c);
}
private void EnsureFigure(CanvasPathBuilder builder)
{
if (!_figureStarted)
{
//_figure = _builder.BeginFigure();
//_figure = new PathFigure();
//_figure.StartPoint = _lastStart;
builder.BeginFigure((float)_lastStart.X, (float)_lastStart.Y, CanvasFigureFill.Default);
//_context.BeginFigure(_lastStart, IsFilled, !IsClosed);
_figureStarted = true;
}
}
public static CanvasGeometry ToCanvasGeometry(this XPathGeometry pg, CanvasDrawingSession ds)
{
CanvasGeometry g;
using (var builder = new CanvasPathBuilder(ds))
{
if (pg.FillRule == XFillRule.EvenOdd)
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Alternate);
else
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Winding);
foreach (var pf in pg.Figures)
{
builder.BeginFigure(
(float)pf.StartPoint.X,
(float)pf.StartPoint.Y,
pf.IsFilled ? CanvasFigureFill.Default : CanvasFigureFill.DoesNotAffectFills);
foreach (var segment in pf.Segments)
{
var options = CanvasFigureSegmentOptions.None;
if (!segment.IsStroked)
options |= CanvasFigureSegmentOptions.ForceUnstroked;
if (segment.IsSmoothJoin)
options |= CanvasFigureSegmentOptions.ForceRoundLineJoin;
builder.SetSegmentOptions(options);
if (segment is XArcSegment)
{
var arcSegment = segment as XArcSegment;
builder.AddArc(
new N.Vector2(
(float)arcSegment.Point.X,
(float)arcSegment.Point.Y),
(float)(arcSegment.Size.Width / 2.0),
(float)(arcSegment.Size.Height / 2.0),
(float)arcSegment.RotationAngle,
arcSegment.SweepDirection == XSweepDirection.Clockwise ? CanvasSweepDirection.Clockwise : CanvasSweepDirection.CounterClockwise,
arcSegment.IsLargeArc ? CanvasArcSize.Large : CanvasArcSize.Small);
}
else if (segment is XBezierSegment)
{
var bezierSegment = segment as XBezierSegment;
builder.AddCubicBezier(
new N.Vector2(
(float)bezierSegment.Point1.X,
(float)bezierSegment.Point1.Y),
new N.Vector2(
(float)bezierSegment.Point2.X,
(float)bezierSegment.Point2.Y),
new N.Vector2(
(float)bezierSegment.Point3.X,
(float)bezierSegment.Point3.Y));
}
else if (segment is XLineSegment)
{
var lineSegment = segment as XLineSegment;
builder.AddLine(
new N.Vector2(
(float)lineSegment.Point.X,
(float)lineSegment.Point.Y));
}
else if (segment is XPolyBezierSegment)
{
var polyBezierSegment = segment as XPolyBezierSegment;
if (polyBezierSegment.Points.Count >= 3)
{
builder.AddCubicBezier(
new N.Vector2(
(float)polyBezierSegment.Points[0].X,
(float)polyBezierSegment.Points[0].Y),
new N.Vector2(
(float)polyBezierSegment.Points[1].X,
(float)polyBezierSegment.Points[1].Y),
new N.Vector2(
(float)polyBezierSegment.Points[2].X,
(float)polyBezierSegment.Points[2].Y));
}
if (polyBezierSegment.Points.Count > 3
&& polyBezierSegment.Points.Count % 3 == 0)
{
for (int i = 3; i < polyBezierSegment.Points.Count; i += 3)
{
builder.AddCubicBezier(
new N.Vector2(
(float)polyBezierSegment.Points[i].X,
(float)polyBezierSegment.Points[i].Y),
new N.Vector2(
(float)polyBezierSegment.Points[i + 1].X,
(float)polyBezierSegment.Points[i + 1].Y),
new N.Vector2(
(float)polyBezierSegment.Points[i + 2].X,
(float)polyBezierSegment.Points[i + 2].Y));
}
}
}
else if (segment is XPolyLineSegment)
{
var polyLineSegment = segment as XPolyLineSegment;
if (polyLineSegment.Points.Count >= 1)
{
builder.AddLine(
new N.Vector2(
(float)polyLineSegment.Points[0].X,
(float)polyLineSegment.Points[0].Y));
}
if (polyLineSegment.Points.Count > 1)
{
for (int i = 1; i < polyLineSegment.Points.Count; i++)
{
builder.AddLine(
new N.Vector2(
(float)polyLineSegment.Points[i].X,
(float)polyLineSegment.Points[i].Y));
}
}
}
else if (segment is XPolyQuadraticBezierSegment)
{
var polyQuadraticSegment = segment as XPolyQuadraticBezierSegment;
if (polyQuadraticSegment.Points.Count >= 2)
{
builder.AddQuadraticBezier(
new N.Vector2(
(float)polyQuadraticSegment.Points[0].X,
(float)polyQuadraticSegment.Points[0].Y),
new N.Vector2(
(float)polyQuadraticSegment.Points[1].X,
(float)polyQuadraticSegment.Points[1].Y));
}
if (polyQuadraticSegment.Points.Count > 2
&& polyQuadraticSegment.Points.Count % 2 == 0)
{
for (int i = 3; i < polyQuadraticSegment.Points.Count; i += 3)
{
builder.AddQuadraticBezier(
new N.Vector2(
(float)polyQuadraticSegment.Points[i].X,
(float)polyQuadraticSegment.Points[i].Y),
new N.Vector2(
(float)polyQuadraticSegment.Points[i + 1].X,
(float)polyQuadraticSegment.Points[i + 1].Y));
}
}
}
else if (segment is XQuadraticBezierSegment)
{
var qbezierSegment = segment as XQuadraticBezierSegment;
builder.AddQuadraticBezier(
new N.Vector2(
(float)qbezierSegment.Point1.X,
(float)qbezierSegment.Point1.Y),
new N.Vector2(
(float)qbezierSegment.Point2.X,
(float)qbezierSegment.Point2.Y));
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
builder.EndFigure(pf.IsClosed ? CanvasFigureLoop.Closed : CanvasFigureLoop.Open);
}
g = CanvasGeometry.CreatePath(builder);
}
return g;
}
internal override void fillPath(CanvasPathBuilder p)
{
setGraphics(canvas.CreateDrawingSession());
base.setClip(clip);
base.fillPath(p);
base.removeClip();
}
// changes the drawing points in graph to be actual graph geometry item which can be used for drawing
private CanvasGeometry getDrawChartGeometry(CanvasDevice device, List<DataPoint> offsetList)
{
if (offsetList == null || offsetList.Count <= 0)
{
return null;
}
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(device);
//start with first point
pathBuilder.BeginFigure((float)offsetList[0].OffsetX, (float)offsetList[0].OffsetY);
for (int i = 0; i < offsetList.Count; i++)
{ // add line to the next point in the offset list
pathBuilder.AddLine((float)offsetList[i].OffsetX, (float)offsetList[i].OffsetY);
}
//end it with open loop, we are not closed geometry object but just a chart-graph
pathBuilder.EndFigure(CanvasFigureLoop.Open);
return CanvasGeometry.CreatePath(pathBuilder);
}
private void DrawSpectrumSpline(IReadOnlyList <float> data, CanvasDrawingSession session, Vector2 offset, float width, float height, float heightScale, Color color, bool rightToLeft = false)
{
int segmentCount = data.Count - 1;
if (segmentCount <= 1 || width <= 0f)
{
return;
}
CanvasPathBuilder path = new CanvasPathBuilder(session);
float segmentWidth = width / (float)segmentCount;
Vector2 prevPosition = rightToLeft ? new Vector2(width + offset.X, data[0] * heightScale * height + offset.Y)
: new Vector2(offset.X, data[0] * heightScale * height + offset.Y);
if (rightToLeft)
{
path.BeginFigure(width + offset.X, height + offset.Y);
}
else
{
path.BeginFigure(offset.X, height + offset.Y);
}
path.AddLine(prevPosition);
for (int i = 1; i < data.Count; i++)
{
Vector2 position = rightToLeft ? new Vector2(width - (float)i * segmentWidth + offset.X, data[i] * heightScale * height + offset.Y)
: new Vector2((float)i * segmentWidth + offset.X, data[i] * heightScale * height + offset.Y);
if (rightToLeft)
{
Vector2 c1 = new Vector2(position.X + segmentWidth / 2.0f, prevPosition.Y);
Vector2 c2 = new Vector2(prevPosition.X - segmentWidth / 2.0f, position.Y);
path.AddCubicBezier(c1, c2, position);
}
else
{
Vector2 c1 = new Vector2(position.X - segmentWidth / 2.0f, prevPosition.Y);
Vector2 c2 = new Vector2(prevPosition.X + segmentWidth / 2.0f, position.Y);
path.AddCubicBezier(c1, c2, position);
}
prevPosition = position;
}
if (rightToLeft)
{
path.AddLine(offset.X, height + offset.Y);
}
else
{
path.AddLine(width + offset.X, height + offset.Y);
}
path.EndFigure(CanvasFigureLoop.Closed);
CanvasGeometry geometry = CanvasGeometry.CreatePath(path);
session.FillGeometry(geometry, color);
}
public void Draw(object ds, XQBezier qbezier, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _ds = ds as CanvasDrawingSession;
double thickness = qbezier.Style.Thickness / _state.Zoom;
var brush = ToColor(qbezier.Style.Fill);
var pen = ToColor(qbezier.Style.Stroke);
var ss = CreateStrokeStyle(qbezier.Style);
CanvasGeometry g;
using (var builder = new CanvasPathBuilder(_ds))
{
builder.BeginFigure((float)qbezier.Point1.X, (float)qbezier.Point1.Y);
builder.AddQuadraticBezier(
new N.Vector2(
(float)qbezier.Point2.X,
(float)qbezier.Point2.Y),
new N.Vector2(
(float)qbezier.Point3.X,
(float)qbezier.Point3.Y));
builder.EndFigure(CanvasFigureLoop.Open);
g = CanvasGeometry.CreatePath(builder);
}
if (qbezier.IsFilled)
{
_ds.FillGeometry(g, brush);
}
if (qbezier.IsStroked)
{
_ds.DrawGeometry(g, pen, (float)thickness, ss);
}
g.Dispose();
ss.Dispose();
}
private void DrawSelectionLasso(CanvasControl sender, CanvasDrawingSession ds)
{
if (selectionPolylinePoints == null) return;
if (selectionPolylinePoints.Count == 0) return;
CanvasPathBuilder selectionLasso = new CanvasPathBuilder(canvasControl);
selectionLasso.BeginFigure(selectionPolylinePoints[0].ToVector2());
for (int i = 1; i < selectionPolylinePoints.Count; ++i)
{
selectionLasso.AddLine(selectionPolylinePoints[i].ToVector2());
}
selectionLasso.EndFigure(CanvasFigureLoop.Open);
CanvasGeometry pathGeometry = CanvasGeometry.CreatePath(selectionLasso);
ds.DrawGeometry(pathGeometry, Colors.Magenta, 5.0f);
}
void CreateClockFace(ICanvasResourceCreator sender)
{
const float begin = center - radius - lineLength / 2;
const float end = center + radius + lineLength / 2;
using (var builder = new CanvasPathBuilder(sender))
{
// Since we have concentric circles that we want to remain filled we want to use Winding to determine the filled region.
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Winding);
builder.AddCircleFigure(new Vector2(center), radius);
builder.AddCircleFigure(new Vector2(center), radius * 0.6f);
builder.AddOneLineFigure(center, begin, center, begin + lineLength);
builder.AddOneLineFigure(center, end - lineLength, center, end);
builder.AddOneLineFigure(begin, center, begin + lineLength, center);
builder.AddOneLineFigure(end - lineLength, center, end, center);
using (CanvasGeometry clockFaceGeometry = CanvasGeometry.CreatePath(builder))
{
clockFaceCachedFill = CanvasCachedGeometry.CreateFill(clockFaceGeometry);
clockFaceCachedStroke18 = CanvasCachedGeometry.CreateStroke(clockFaceGeometry, 18, timeCircleStrokeStyle);
clockFaceCachedStroke16 = CanvasCachedGeometry.CreateStroke(clockFaceGeometry, 16, timeCircleStrokeStyle);
}
}
}
public static void AddCircleFigure(this CanvasPathBuilder builder, Vector2 center, float radius)
{
builder.BeginFigure(center + Vector2.UnitX * radius);
builder.AddArc(center, radius, radius, 0, (float)Math.PI * 2);
builder.EndFigure(CanvasFigureLoop.Closed);
}
static CanvasGeometry CreateTimeSegmentGeometry(CanvasDrawingSession ds, double fractionSecond)
{
double fractionSecondAngle = 2 * Math.PI * fractionSecond;
double angle = fractionSecondAngle % (2 * Math.PI);
using (var builder = new CanvasPathBuilder(ds))
{
builder.BeginFigure(center, center);
builder.AddArc(new Vector2(center), radius, radius, (float)Math.PI * 3 / 2, (float)angle);
builder.EndFigure(CanvasFigureLoop.Closed);
return CanvasGeometry.CreatePath(builder);
}
}
public void AddPathSegment(CanvasPathBuilder canvasPathBuilder, ref bool closed)
{
canvasPathBuilder.AddCubicBezier(_control1, _control2, _vertex);
closed = false;
}
void DrawBezier(CanvasDrawingSession drawingSession, Vector2 start, Vector2 ctrl0, Vector2 ctrl1, Vector2 end)
{
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(canvasControl);
pathBuilder.BeginFigure(start);
pathBuilder.AddCubicBezier(ctrl0, ctrl1, end);
pathBuilder.EndFigure(CanvasFigureLoop.Open);
CanvasGeometry geometry = CanvasGeometry.CreatePath(pathBuilder);
drawingSession.DrawGeometry(geometry, Colors.White, 5.0f);
}
public void AddPathSegment(CanvasPathBuilder canvasPathBuilder, ref bool closed)
{
canvasPathBuilder.AddArc(_endPoint, _a / 2, _b / 2, _sweepAngle, CanvasSweepDirection.Clockwise, CanvasArcSize.Small);
closed = false;
}
void Redraw(CanvasControl canvas, CanvasDrawEventArgs args)
{
for (int y = -2; y <= (int)Math.Ceiling(canvas.ActualHeight / TileSize.Height * 2) + 1; ++y)
{
for (int x = -2; x <= (int)Math.Ceiling(canvas.ActualWidth / TileSize.Width) + 1; ++x)
{
Vector2 onscreenTile = new Vector2(0.0f, 0.0f);
var path = new CanvasPathBuilder(canvas);
if (TileShape == MapTileShape.Square)
{
onscreenTile.X = (float)Math.Floor((double)(x + (y / 2)));
onscreenTile.Y = (float)Math.Floor((double)(-x + (y / 2) + (y % 2)));
var tileRect = new Rect(onscreenTile.X, onscreenTile.Y, 1, 1);
path.BeginFigure(
MapToScreen(
new Vector2((float)tileRect.Left, (float)tileRect.Top)));
path.AddLine(
MapToScreen(
new Vector2((float)tileRect.Right, (float)tileRect.Top)));
path.AddLine(
MapToScreen(
new Vector2((float)tileRect.Right, (float)tileRect.Bottom)));
path.AddLine(
MapToScreen(
new Vector2((float)tileRect.Left, (float)tileRect.Bottom)));
path.EndFigure(CanvasFigureLoop.Closed);
}
else if (TileShape == MapTileShape.Hexagon)
{
onscreenTile.X = (float)x;
onscreenTile.Y = (float)y;
var topLeft = MapToScreen(onscreenTile);
var bottomRight = new Vector2(
(float)(topLeft.X + TileSize.Width),
(float)(topLeft.Y + TileSize.Height));
#if HORIZONTAL_HEXAGONS
path.BeginFigure(new Vector2(
topLeft.X + 0.25f * (float)TileSize.Width,
topLeft.Y));
path.AddLine(new Vector2(
bottomRight.X - 0.25f * (float)TileSize.Width,
topLeft.Y));
path.AddLine(new Vector2(
bottomRight.X,
topLeft.Y + 0.5f * (float)TileSize.Height));
path.AddLine(new Vector2(
bottomRight.X - 0.25f * (float)TileSize.Width,
bottomRight.Y));
path.AddLine(new Vector2(
topLeft.X + 0.25f * (float)TileSize.Width,
bottomRight.Y));
path.AddLine(new Vector2(
topLeft.X,
topLeft.Y + 0.5f * (float)TileSize.Height));
#else
path.BeginFigure(new Vector2(
topLeft.X + 0.5f * (float)TileSize.Width,
topLeft.Y));
path.AddLine(new Vector2(
bottomRight.X,
topLeft.Y + 0.25f * (float)TileSize.Height));
path.AddLine(new Vector2(
bottomRight.X,
bottomRight.Y - 0.25f * (float)TileSize.Height));
path.AddLine(new Vector2(
bottomRight.X - 0.5f * (float)TileSize.Width,
bottomRight.Y));
path.AddLine(new Vector2(
topLeft.X,
bottomRight.Y - 0.25f * (float)TileSize.Height));
path.AddLine(new Vector2(
topLeft.X,
topLeft.Y + 0.25f * (float)TileSize.Height));
#endif
path.EndFigure(CanvasFigureLoop.Closed);
}
var tile = onscreenTile + TileOffset;
var geometry = CanvasGeometry.CreatePath(path);
if (tile == HighlightedTile)
{
args.DrawingSession.FillGeometry(geometry, Colors.CornflowerBlue);
args.DrawingSession.DrawGeometry(geometry, Color.FromArgb(255, 40, 40, 40));
}
else
{
args.DrawingSession.FillGeometry(geometry, Colors.White);
args.DrawingSession.DrawGeometry(geometry, Colors.Black);
}
}
}
}
