public static CanvasGeometry CreateGroup(
CanvasDevice?device,
CanvasGeometry[] geometries,
CanvasFilledRegionDetermination filledRegionDetermination)
=> new Group(geometries)
{
FilledRegionDetermination = filledRegionDetermination,
};
public void SetFilledRegionDetermination(CanvasFilledRegionDetermination filledRegionDetermination)
{
if (_builder.Length == 0)
{
return;
}
_builder.AppendFormat("F {0} ", (int)filledRegionDetermination);
}
public void SetFilledRegionDetermination(CanvasFilledRegionDetermination value)
{
if (_isFilledRegionDeterminationSet)
{
// Throw if someone attempts to set the CanvasFilledRegionDetermination twice.
// We could handle it, but it almost certainly indicates an accidental use
// of the API.
throw new InvalidOperationException();
}
_isFilledRegionDeterminationSet = true;
FilledRegionDetermination = value;
}
public virtual string FilledRegionDetermination(CanvasFilledRegionDetermination value)
{
var typeName = nameof(CanvasFilledRegionDetermination);
switch (value)
{
case CanvasFilledRegionDetermination.Alternate: return($"{typeName}{ScopeResolve}Alternate");
case CanvasFilledRegionDetermination.Winding: return($"{typeName}{ScopeResolve}Winding");
default: throw new InvalidOperationException();
}
}
public override string FilledRegionDetermination(CanvasFilledRegionDetermination value)
{
switch (value)
{
case CanvasFilledRegionDetermination.Alternate:
return("CanvasFilledRegionDetermination.Alternate");
case CanvasFilledRegionDetermination.Winding:
return("CanvasFilledRegionDetermination.Winding");
default:
throw new InvalidOperationException();
}
}
static CanvasGeometry MakeGeometry(IEnumerable <Data.Path> paths, CanvasFilledRegionDetermination fillRule = CanvasFilledRegionDetermination.Winding)
{
var device = CanvasDevice.GetSharedDevice();
using var builder = new CanvasPathBuilder(device);
if (paths != null)
{
foreach (var path in paths)
{
builder.AddGeometry(path.CanvasPath);
}
}
builder.SetFilledRegionDetermination(fillRule);
return(CanvasGeometry.CreatePath(builder));
}
/// <summary>
/// Specifies the method used to determine which points are inside the geometry described
/// by this path builder, and which points are outside.
/// </summary>
/// <param name="filledRegionDetermination"> The determination for filled region.</param>
public void SetFilledRegionDetermination(CanvasFilledRegionDetermination filledRegionDetermination)
{
this.FilledRegionDetermination = filledRegionDetermination;
}
public static CanvasGeometry AsPath(this PathF path, float ox, float oy, float fx, float fy, ICanvasResourceCreator creator, CanvasFilledRegionDetermination fillMode = CanvasFilledRegionDetermination.Winding)
{
var builder = new CanvasPathBuilder(creator);
#if DEBUG
try
{
#endif
builder.SetFilledRegionDetermination(fillMode);
var pointIndex = 0;
var arcAngleIndex = 0;
var arcClockwiseIndex = 0;
var figureOpen = false;
var segmentIndex = -1;
var lastOperation = PathOperation.Move;
foreach (var type in path.SegmentTypes)
{
segmentIndex++;
if (type == PathOperation.Move)
{
if (lastOperation != PathOperation.Close && lastOperation != PathOperation.Move)
{
builder.EndFigure(CanvasFigureLoop.Open);
}
var point = path[pointIndex++];
var begin = CanvasFigureFill.Default;
builder.BeginFigure(ox + point.X * fx, oy + point.Y * fy, begin);
figureOpen = true;
}
else if (type == PathOperation.Line)
{
var point = path[pointIndex++];
builder.AddLine(ox + point.X * fx, oy + point.Y * fy);
}
else if (type == PathOperation.Quad)
{
var controlPoint = path[pointIndex++];
var endPoint = path[pointIndex++];
builder.AddQuadraticBezier(
new Vector2(ox + controlPoint.X * fx, oy + controlPoint.Y * fy),
new Vector2(ox + endPoint.X * fx, oy + endPoint.Y * fy));
}
else if (type == PathOperation.Cubic)
{
var controlPoint1 = path[pointIndex++];
var controlPoint2 = path[pointIndex++];
var endPoint = path[pointIndex++];
builder.AddCubicBezier(
new Vector2(ox + controlPoint1.X * fx, oy + controlPoint1.Y * fy),
new Vector2(ox + controlPoint2.X * fx, oy + controlPoint2.Y * fy),
new Vector2(ox + endPoint.X * fx, oy + endPoint.Y * fy));
}
else if (type == PathOperation.Arc)
{
var topLeft = path[pointIndex++];
var bottomRight = path[pointIndex++];
var startAngle = path.GetArcAngle(arcAngleIndex++);
var endAngle = path.GetArcAngle(arcAngleIndex++);
var clockwise = path.GetArcClockwise(arcClockwiseIndex++);
while (startAngle < 0)
{
startAngle += 360;
}
while (endAngle < 0)
{
endAngle += 360;
}
var rotation = Geometry.GetSweep(startAngle, endAngle, clockwise);
var absRotation = Math.Abs(rotation);
var rectX = ox + topLeft.X * fx;
var rectY = oy + topLeft.Y * fy;
var rectWidth = (ox + bottomRight.X * fx) - rectX;
var rectHeight = (oy + bottomRight.Y * fy) - rectY;
var startPoint = Geometry.EllipseAngleToPoint(rectX, rectY, rectWidth, rectHeight, -startAngle);
var endPoint = Geometry.EllipseAngleToPoint(rectX, rectY, rectWidth, rectHeight, -endAngle);
if (!figureOpen)
{
var begin = CanvasFigureFill.Default;
builder.BeginFigure(startPoint.X, startPoint.Y, begin);
figureOpen = true;
}
else
{
builder.AddLine(startPoint.X, startPoint.Y);
}
builder.AddArc(
new Vector2(endPoint.X, endPoint.Y),
rectWidth / 2,
rectHeight / 2,
0,
clockwise ? CanvasSweepDirection.Clockwise : CanvasSweepDirection.CounterClockwise,
absRotation >= 180 ? CanvasArcSize.Large : CanvasArcSize.Small
);
}
else if (type == PathOperation.Close)
{
builder.EndFigure(CanvasFigureLoop.Closed);
}
lastOperation = type;
}
if (segmentIndex >= 0 && lastOperation != PathOperation.Close)
{
builder.EndFigure(CanvasFigureLoop.Open);
}
var geometry = CanvasGeometry.CreatePath(builder);
return(geometry);
#if DEBUG
}
catch (Exception exc)
{
builder.Dispose();
var definition = path.ToDefinitionString();
Logger.Debug(string.Format("Unable to convert the path to a Win2D Path: {0}", definition), exc);
return(null);
}
#endif
}
public static CanvasGeometry AsPath(this PathF path, ICanvasResourceCreator creator, CanvasFilledRegionDetermination fillMode = CanvasFilledRegionDetermination.Winding)
{
return(AsPath(path, 0, 0, 1, 1, creator, fillMode));
}
string FilledRegionDetermination(CanvasFilledRegionDetermination value) => _stringifier.FilledRegionDetermination(value);
public void SetFilledRegionDetermination(CanvasFilledRegionDetermination filledRegionDetermination)
{
wasSetFilledRegionDeterminationCalled = true;
}
public void SetFilledRegionDetermination(CanvasFilledRegionDetermination filledRegionDetermination)
{
// Ignored
}
public void SetFilledRegionDetermination(CanvasFilledRegionDetermination filledRegionDetermination)
{
wasSetFilledRegionDeterminationCalled = true;
}
public abstract string FilledRegionDetermination(CanvasFilledRegionDetermination value);
/// <summary>
/// ctor
/// </summary>
public FillRuleElement()
{
_fillValue = CanvasFilledRegionDetermination.Alternate;
}
public void SetFilledRegionDetermination(CanvasFilledRegionDetermination arg)
{
}
public static CanvasGeometry CreateGroup(object arg0, CanvasGeometry[] arg1, CanvasFilledRegionDetermination arg3) => null;
/// <summary>
/// Specifies the method used to determine which points are inside the geometry described by this path builder, and which points are outside.
/// </summary>
/// <param name="filledRegionDetermination"><see cref="CanvasFilledRegionDetermination"/></param>
public void SetFilledRegionDetermination(CanvasFilledRegionDetermination filledRegionDetermination)
{
_cmdBuilder.AppendLine($" pathBuilder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.{filledRegionDetermination});");
}
internal void SetFillRule(CanvasFilledRegionDetermination fillRule)
{
this.fillRule = fillRule;
InvalidateGeometry();
}
