public void drawGrid(double s, CanvasDrawingSession ds)
{
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(ds);
for (float x0 = 0.5f; x0 < 8.5f; x0 += 1)
{
pathBuilder.BeginFigure(0, x0);
for (float y0 = 0.5f; y0 < 8.5; y0 += 0.5f)
{
var a = Math.Atan2(y0, x0) * 2 / 3;
var r = Math.Sqrt(x0 * x0 + y0 * y0);
var x = r * Math.Sin(a);
var y = r * Math.Cos(a);
pathBuilder.AddLine((float)x, (float)y);
}
pathBuilder.EndFigure(CanvasFigureLoop.Open);
}
// rotate and reflect the result
var onep = CanvasGeometry.CreatePath(pathBuilder);
for (int a = 0; a < 6; a++)
{
var m = Matrix3x2.Identity * Matrix.CreateRotation(Math.PI / 6 + a * Math.PI / 3);
ds.DrawGeometry(onep.Transform(m), Colors.DarkGray, 1 / (float)s);
m = m * Matrix.CreateScale(1, -1);
ds.DrawGeometry(onep.Transform(m), Colors.DarkGray, 1 / (float)s);
}
}
public bool DrawString(
CanvasDrawingSession graphics,
CanvasTextLayout textLayout,
float x, float y)
{
using (CanvasGeometry geometry = CanvasGeometry.CreateText(textLayout))
{
CanvasStrokeStyle stroke = new CanvasStrokeStyle();
stroke.DashStyle = CanvasDashStyle.Solid;
stroke.DashCap = CanvasCapStyle.Round;
stroke.StartCap = CanvasCapStyle.Round;
stroke.EndCap = CanvasCapStyle.Round;
stroke.LineJoin = CanvasLineJoin.Round;
for (int i = m_nThickness1; i <= m_nThickness1 + m_nThickness2; ++i)
{
graphics.DrawGeometry(geometry, x, y, m_clrOutline2, i, stroke);
}
graphics.DrawGeometry(geometry, x, y, m_clrOutline1, m_nThickness1, stroke);
if (m_bClrText)
{
graphics.FillGeometry(geometry, x, y, m_clrText);
}
else
{
graphics.FillGeometry(geometry, x, y, m_brushText);
}
}
return(true);
}
public void Draw(CanvasDrawingSession cds)
{
if (this.Selected == true)
{
cds.DrawGeometry(this.Line, this.SelectedLineColor, this.LineWidth);
}
else
{
cds.DrawGeometry(this.Line, this.LineColor, this.LineWidth);
}
}
public void Draw(CanvasDrawingSession cds)
{
Debug.WriteLine("Drawing Vertex");
if (this.Selected == true)
{
cds.DrawGeometry(this.Circle, this.SelectedLineColor, this.LineWidth);
}
else
{
cds.DrawGeometry(this.Circle, this.LineColor, this.LineWidth);
}
this.Redraw = false;
}
private void RenderData(CanvasDrawingSession ds, double width, double height)
{
if (data.Count == 0)
{
return;
}
float thickness = 1;
float w = (float)width * data.Count / 300;
float xs = w / data.Count;
float x0 = (float)width - w;
using (var cpb = new CanvasPathBuilder(ds))
{
cpb.BeginFigure(new Vector2((float)(axis[0] * width), (float)(height * (1 - data[0]))));
for (int i = 1; i < data.Count; i++)
{
//cpb.AddLine(new Vector2(i*xs + x0, (float)(height * (1 - data[i]))));
cpb.AddLine(new Vector2((float)(axis[i] * width), (float)(height * (1 - data[i]))));
}
if (renderArea)
{
cpb.AddLine(new Vector2(data.Count * xs + x0, (float)height));
cpb.AddLine(new Vector2(x0, (float)height));
cpb.EndFigure(CanvasFigureLoop.Closed);
ds.FillGeometry(CanvasGeometry.CreatePath(cpb), color);
}
else
{
cpb.EndFigure(CanvasFigureLoop.Open);
ds.DrawGeometry(CanvasGeometry.CreatePath(cpb), color, thickness);
}
}
}
internal override void Draw(CanvasControl cc, CanvasDrawingSession ds, float scale, Vector2 center, FlipState flip)
{
var color = GetColor(Coloring.Normal);
var points = GetDrawingPoints(flip, scale, center);
if (points.Length == 2)
{
ds.DrawLine(points[0], points[1], color, StrokeWidth, StrokeStyle());
}
else if (points.Length > 2)
{
using (var pb = new CanvasPathBuilder(cc))
{
pb.BeginFigure(points[0]);
for (int i = 1; i < points.Length; i++)
{
pb.AddLine(points[i]);
}
pb.EndFigure(CanvasFigureLoop.Open);
using (var geo = CanvasGeometry.CreatePath(pb))
{
if (FillStroke == Fill_Stroke.Filled)
{
ds.FillGeometry(geo, color);
}
else
{
ds.DrawGeometry(geo, color, StrokeWidth, StrokeStyle());
}
}
}
}
}
internal override void Draw(CanvasControl cc, CanvasDrawingSession ds, float scale, Vector2 center, FlipState flip)
{
var color = GetColor(Coloring.Normal);
var points = GetDrawingPoints(flip, scale, center);
using (var pb = new CanvasPathBuilder(cc))
{
pb.BeginFigure(points[0]);
var N = DXY.Count;
for (var i = 0; i < N - 2;)
{
pb.AddCubicBezier(points[i], points[++i], points[++i]);
}
pb.EndFigure(CanvasFigureLoop.Open);
using (var geo = CanvasGeometry.CreatePath(pb))
{
if (FillStroke == Fill_Stroke.Filled)
{
ds.FillGeometry(geo, color);
}
else
{
ds.DrawGeometry(geo, color, StrokeWidth, StrokeStyle());
}
}
}
}
public static void DrawComponents(Data.Layer layer, CanvasDrawingSession ds, float rescale, Color componentColor,
bool drawSelection = false)
{
var margin = 4 * rescale;
var originColor = Color.FromArgb(135, 34, 34, 34);
var selectedComponentColor = Color.FromArgb(
135,
(byte)Math.Max(componentColor.R - 90, 0),
(byte)Math.Max(componentColor.G - 90, 0),
(byte)Math.Max(componentColor.B - 90, 0)
);
foreach (var component in layer.Components)
{
ds.FillGeometry(component.ClosedCanvasPath, drawSelection && component.IsSelected ? selectedComponentColor : componentColor);
ds.DrawGeometry(component.OpenCanvasPath, componentColor, strokeWidth: rescale);
if (drawSelection && component.IsSelected)
{
var origin = component.Origin;
ds.DrawLine(origin.X, origin.Y + margin, origin.X, origin.Y - margin, originColor, strokeWidth: rescale);
ds.DrawLine(origin.X - margin, origin.Y, origin.X + margin, origin.Y, originColor, strokeWidth: rescale);
}
}
}
private void DrawDryInk_GeometryMethod(CanvasDrawingSession ds, IReadOnlyList <InkStroke> strokes)
{
//
// This converts the ink strokes to geometry, then draws the geometry outline
// with a dotted stroke style.
//
var strokeStyle = new CanvasStrokeStyle {
DashStyle = CanvasDashStyle.Dot
};
var strokesGroupedByColor = from stroke in strokes
where !IsPencilStroke(stroke)
group stroke by stroke.DrawingAttributes.Color into strokesOfColor
select strokesOfColor;
foreach (var strokesOfColor in strokesGroupedByColor)
{
var geometry = CanvasGeometry.CreateInk(ds, strokesOfColor.ToList()).Outline();
ds.DrawGeometry(geometry, strokesOfColor.Key, 1, strokeStyle);
}
// Display text labels in place of any pencil strokes, because we cannot create geometry for those.
foreach (var pencilStroke in strokes.Where(IsPencilStroke))
{
ds.DrawText("CanvasGeometry.CreateInk does not support pencil strokes",
pencilStroke.BoundingRect,
pencilStroke.DrawingAttributes.Color,
centerTextFormat);
}
}
private void DrawDryInk_CustomGeometryMethod(CanvasDrawingSession ds, IReadOnlyList <InkStroke> strokes)
{
//
// This shows off the fact that apps can use the custom drying path
// to render dry ink using Win2D, and not necessarily
// rely on the built-in rendering in CanvasDrawingSession.DrawInk.
//
foreach (var stroke in strokes)
{
var color = stroke.DrawingAttributes.Color;
var inkPoints = stroke.GetInkPoints();
if (inkPoints.Count > 0)
{
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(canvasControl);
pathBuilder.BeginFigure(inkPoints[0].Position.ToVector2());
for (int i = 1; i < inkPoints.Count; i++)
{
pathBuilder.AddLine(inkPoints[i].Position.ToVector2());
ds.DrawCircle(inkPoints[i].Position.ToVector2(), 3, color);
}
pathBuilder.EndFigure(CanvasFigureLoop.Open);
CanvasGeometry geometry = CanvasGeometry.CreatePath(pathBuilder);
ds.DrawGeometry(geometry, color);
}
}
}
public void DrawPath(Path path, Paint paint)
{
UpdateDrawingSessionWithFlags(paint.Flags);
_drawingSession.Transform = GetCurrentTransform();
var gradient = paint.Shader as Gradient;
var brush = gradient != null?gradient.GetBrush(_device, paint.Alpha) : new CanvasSolidColorBrush(_device, paint.Color);
brush = paint.ColorFilter?.Apply(this, brush) ?? brush;
using (var geometry = path.GetGeometry(_device))
{
if (paint.Style == Paint.PaintStyle.Stroke)
{
_drawingSession.DrawGeometry(geometry, brush, paint.StrokeWidth, GetCanvasStrokeStyle(paint));
}
else
{
_drawingSession.FillGeometry(geometry, brush);
}
}
if (gradient == null)
{
brush.Dispose();
}
}
public void DisplayRegionEditInProgress(CanvasDrawingSession drawingSession, List <Vector2> points, float zoomFactor)
{
if (RegionSelectionMode == SelectionMode.MagicWand)
{
// Display a magic wand selection.
var mask = GetMagicWandMask(points, zoomFactor);
var border = GetSelectionBorder(mask, zoomFactor);
drawingSession.Blend = CanvasBlend.Add;
drawingSession.DrawImage(mask, Vector2.Zero, SourceBitmap.Bounds, 0.25f);
drawingSession.Blend = CanvasBlend.SourceOver;
drawingSession.DrawImage(border);
}
else
{
// Display a geometric shape selection.
var geometry = GetSelectionGeometry(drawingSession, points);
drawingSession.Blend = CanvasBlend.Add;
drawingSession.FillGeometry(geometry, Color.FromArgb(0x20, 0xFF, 0xFF, 0xFF));
drawingSession.Blend = CanvasBlend.SourceOver;
drawingSession.DrawGeometry(geometry, Colors.Magenta, 1f / zoomFactor);
}
}
/// <summary>
///
/// </summary>
/// <param name="cds"></param>
/// <param name="dn"></param>
public static void DrawNode(
CanvasDrawingSession cds,
DrawableVertex dn)
{
//cds.DrawCircle(dn.Position, Defines.VERTEX_SIZE, Defines.DEFAULT_NODE_COLOR, Defines.NODE_LINE_WIDTH);
cds.DrawGeometry(dn.Circle, Defines.DEFAULT_NODE_COLOR, Defines.NODE_LINE_WIDTH);
}
public void DrawCommon(CanvasDrawingSession g)
{
//save tansform
var save = g.Transform;
g.FillRectangle(new Rect(P11.X - 2, P11.Y - 2, 4, 4), Pen.Color);
using (var pathBuilder = new CanvasPathBuilder(g))
{
pathBuilder.BeginFigure(P11);
pathBuilder.AddLine(P12);
pathBuilder.AddLine(P22);
pathBuilder.AddLine(P21);
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
g.DrawGeometry(CanvasGeometry.CreatePath(pathBuilder), Pen.Color, Pen.Width);
}
if (IsGlyphVisible)
{
drawOrthogonalGlyph(g, P11, P12, P21);
drawOrthogonalGlyph(g, P12, P11, P22);
drawOrthogonalGlyph(g, P21, P11, P22);
drawOrthogonalGlyph(g, P22, P21, P12);
}
drawMeasure(g, P11, P12);
drawMeasure(g, P12, P22);
drawMeasure(g, P22, P21);
drawMeasure(g, P21, P11);
//recover transform
g.Transform = save;
}
private void DrawFileViewLasso(
CanvasDrawingSession ds, float leftTop, float leftHeight, float rightTop, float rightHeight)
{
var pathBuilder = new CanvasPathBuilder(ds);
float num1 = Math.Min(4.0f, leftHeight * 0.5f); // bezier curve control point
float num2 = Math.Min(4.0f, rightHeight * 0.5f); // bezier curve control point
float y1 = leftTop + leftHeight;
float y2 = rightTop + rightHeight;
pathBuilder.BeginFigure(new Vector2(32.0f, leftTop));
pathBuilder.AddLine(new Vector2(36.0f, rightTop));
pathBuilder.AddLine(new Vector2(56.0f, rightTop));
pathBuilder.AddQuadraticBezier(new Vector2(60.0f, rightTop), new Vector2(60.0f, rightTop + num2));
pathBuilder.AddLine(new Vector2(60.0f, y2 - num2));
pathBuilder.AddQuadraticBezier(new Vector2(60.0f, y2), new Vector2(56.0f, y2));
pathBuilder.AddLine(new Vector2(36.0f, y2));
pathBuilder.AddLine(new Vector2(32.0f, y1));
pathBuilder.AddLine(new Vector2(12.0f, y1));
pathBuilder.AddQuadraticBezier(new Vector2(8.0f, y1), new Vector2(8.0f, y1 - num1));
pathBuilder.AddLine(new Vector2(8.0f, leftTop + num1));
pathBuilder.AddQuadraticBezier(new Vector2(8.0f, leftTop), new Vector2(12.0f, leftTop));
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
var finalGeo = CanvasGeometry.CreatePath(pathBuilder);
ds.DrawGeometry(finalGeo, _lassoColor);
}
public void Draw(CanvasRenderTarget crt, Color lineColor, float lineWidth, Color fillColor, Matrix3x2 m)
{
//CanvasDevice device = CanvasDevice.GetSharedDevice();
//CanvasRenderTarget offscreen = new CanvasRenderTarget(device, width, height, 96);
using (CanvasDrawingSession ds = crt.CreateDrawingSession())
{
//ds.Clear(Colors.Transparent);
//ds.DrawRectangle(100, 200, 5, 6, Colors.Red);
// Debug.WriteLine(_cg.ComputeBounds().ToString());
if (m.IsIdentity == false)
{
_cg = _cg.Transform(m);
//Debug.WriteLine(_cg.ComputeBounds().ToString());
}
if (!(lineColor == Colors.Transparent))
{
ds.DrawGeometry(_cg, lineColor, lineWidth);
}
if (fillColor != null)
{
ds.FillGeometry(_cg, fillColor);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="cds"></param>
/// <param name="de"></param>
public static void DrawEdge(
CanvasDrawingSession cds,
DrawableEdge de)
{
//cds.DrawLine(de.HeadPosition, de.TailPosition, Defines.DEF_EDGE_COLOR, Defines.DEF_EDGE_LINE_WIDTH);
cds.DrawGeometry(de.Line, Defines.DEFAULT_NODE_COLOR, Defines.NODE_LINE_WIDTH);
}
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);
}
/// <summary>
/// Draws a Squircle of the specified dimensions, using a CanvasStroke to define the stroke
/// width, the stroke color and stroke style.
/// </summary>
/// <param name="session">CanvasDrawingSession</param>
/// <param name="x">Offset of the top left corner of the Squircle on the x-axis</param>
/// <param name="y">Offset of the top left corner of the Squircle on the y-axis</param>
/// <param name="w">Width of the Squircle</param>
/// <param name="h">Height of the Squircle</param>
/// <param name="radiusX">Corner Radius on the x axis</param>
/// <param name="radiusY">Corner Radius on the y axis</param>
/// <param name="offset">Offset of the Squircle from the origin.</param>
/// <param name="stroke">CanvasStroke defining the stroke width, the stroke
/// color and stroke style.</param>
public static void DrawSquircle(this CanvasDrawingSession session, float x, float y, float w, float h,
float radiusX, float radiusY, Vector2 offset, ICanvasStroke stroke)
{
using (var geometry = CanvasObject.CreateSquircle(session.Device, x, y, w, h, radiusX, radiusY))
{
session.DrawGeometry(geometry, offset, stroke);
}
}
/// <summary>
/// Draw lines on bound.
/// </summary>
/// <param name="drawingSession"> The drawing-session. </param>
/// <param name="matrix"> The matrix. </param>
/// <param name="accentColor"> The accent color. </param>
public override void DrawBound(CanvasDrawingSession drawingSession, Matrix3x2 matrix, Windows.UI.Color accentColor)
{
if (this.Geometry2 == null)
{
return;
}
drawingSession.DrawGeometry(this.Geometry2.Transform(matrix), accentColor);
}
private void RenderCheck(CanvasDrawingSession session)
{
if (checkGeometry == null)
{
checkGeometry = CreateGeometry(session);
}
session.DrawGeometry(checkGeometry, Colors.Black, 2);
}
static void DrawContactGeometry(CanvasDrawingSession ds, CanvasGeometry geom)
{
if (geom == null)
{
return;
}
ds.FillGeometry(geom, Colors.Green);
ds.DrawGeometry(geom, Colors.Blue, 5);
}
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 Render(Win2DRenderable renderable, CanvasDrawingSession session, Win2DColor color, bool renderControls)
{
if (hullGeometry == null)
{
return;
}
session.DrawGeometry(hullGeometry, renderable.Resources.Brush(color.Normal, 1.0f), 1f);
session.FillGeometry(hullGeometry, renderable.Resources.Brush(color.Lighter, 0.5f));
}
public void Draw(double targetElapsedTimeInMs, long updateCount, CanvasDrawingSession ds)
{
ds.FillGeometry(clockFaceGeometry, backgroundBrush);
double updatesPerSecond = 1000.0 / targetElapsedTimeInMs;
int seconds = (int)((updateCount / updatesPerSecond) % 10);
hueRotationEffect.Angle = (float)Math.PI * (seconds / 10.0f) * 2.0f;
using (var timeSegmentGeometry = CreateTimeSegmentGeometry(ds, updateCount, updatesPerSecond))
{
ds.FillGeometry(timeSegmentGeometry, foregroundBrush);
DrawSecondsText(ds, new Vector2(center), seconds);
ds.DrawGeometry(timeSegmentGeometry, Colors.White, 1, hairlineStrokeStyle);
}
ds.DrawGeometry(clockFaceGeometry, Colors.White, 18, timeCircleStrokeStyle);
ds.DrawGeometry(clockFaceGeometry, Colors.Black, 16, timeCircleStrokeStyle);
}
public async Task <Size> DrawOutlineText(int dim, string font, string text, string saved_file)
{
Size size = new Size();
CanvasDevice device = CanvasDevice.GetSharedDevice();
using (CanvasRenderTarget offscreen = new CanvasRenderTarget(device, dim, dim, 96, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized,
CanvasAlphaMode.Premultiplied))
{
using (CanvasDrawingSession ds = offscreen.CreateDrawingSession())
{
ds.Clear(ColorHelper.FromArgb(255, 255, 255, 255));
Color text_color = Colors.White;
CanvasSolidColorBrush brush = new CanvasSolidColorBrush(device, text_color);
CanvasTextFormat format = new CanvasTextFormat();
format.FontFamily = font;
format.FontStyle = Windows.UI.Text.FontStyle.Normal;
format.FontSize = 60;
format.FontWeight = Windows.UI.Text.FontWeights.Bold;
float layoutWidth = dim;
float layoutHeight = dim;
CanvasTextLayout textLayout = new CanvasTextLayout(device, text, format, layoutWidth, layoutHeight);
CanvasGeometry geometry = CanvasGeometry.CreateText(textLayout);
CanvasStrokeStyle stroke = new CanvasStrokeStyle();
stroke.DashStyle = CanvasDashStyle.Solid;
stroke.DashCap = CanvasCapStyle.Round;
stroke.StartCap = CanvasCapStyle.Round;
stroke.EndCap = CanvasCapStyle.Round;
stroke.LineJoin = CanvasLineJoin.Round;
ds.DrawGeometry(geometry, 10.0f, 10.0f, Colors.Black, 10.0f, stroke);
ds.FillGeometry(geometry, 10.0f, 10.0f, brush);
}
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.TemporaryFolder;
string saved_file2 = "\\";
saved_file2 += saved_file;
await offscreen.SaveAsync(storageFolder.Path + saved_file2);
imgOutlineText.Source = new BitmapImage(new Uri(storageFolder.Path + saved_file2));
using (CanvasDrawingSession ds = offscreen.CreateDrawingSession())
{
ds.Clear(Colors.White);
}
return(size);
}
}
public void RenderObstacles(IObstacle[] obstacles)
{
foreach (var obs in obstacles)
{
var geom = CanvasGeometry.CreatePolygon(canvas, obs.Points);
var color = HexToColor("#ff032939");
session.DrawGeometry(geom, color, 3, new CanvasStrokeStyle {
LineJoin = CanvasLineJoin.Round
});
//session.FillGeometry(geom, color);
}
}
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 virtual void Draw(CanvasDrawingSession g, bool drawSelected = true)
{
if (drawSelected && IsSelected)
{
var groups = new CanvasGeometry[Geometries.Count];
for (int i = 0; i < groups.Length; i++)
{
groups[i] = Geometries[i].Geometry;
}
using (var group = CanvasGeometry.CreateGroup(g, groups))
{
var bounds = group.ComputeBounds();
g.FillRectangle(bounds, Color.FromArgb(0x22, 0, 0, 0));
g.DrawRectangle(bounds, Context.SelectedBorderColor, Context.SelectedBorderWidth);
}
}
foreach (var item in Geometries)
{
if (!item.IsDrawUnit)
{
continue;
}
switch (item.Style)
{
case GeometryStyle.Stroke:
g.DrawGeometry(item.Geometry, item.StrokeColor, item.StrokeWidth);
break;
case GeometryStyle.Fill:
g.FillGeometry(item.Geometry, item.FillColor);
break;
case GeometryStyle.Both:
g.DrawGeometry(item.Geometry, item.StrokeColor, item.StrokeWidth);
g.FillGeometry(item.Geometry, item.FillColor);
break;
}
}
}
private void DrawStar(CanvasControl sender, CanvasDrawingSession ds)
{
var width = (float)sender.ActualWidth;
var height = (float)sender.ActualHeight;
var stroke = this.defaultStroke;
var scale = (width / 2) - (stroke * 2);
var center = new Vector2(width / 2, height / 2);
var starGeometry = CreateStarGeometry(sender, scale, center);
ds.FillGeometry(starGeometry, ForegroundColor);
ds.DrawGeometry(starGeometry, GlowColor, stroke);
}
