470 lines
22 KiB
C#
470 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Windows;
|
|
using System.Windows.Media;
|
|
using HandyControl.Expression.Drawing;
|
|
|
|
namespace HandyControl.Expression.Media
|
|
{
|
|
internal class ArcGeometrySource : GeometrySource<IArcGeometrySourceParameters>
|
|
{
|
|
private double _absoluteThickness;
|
|
|
|
private double _relativeThickness;
|
|
|
|
private static bool AreCloseEnough(double angleA, double angleB)
|
|
{
|
|
return Math.Abs(angleA - angleB) < 0.001;
|
|
}
|
|
|
|
internal static double[] ComputeAngleRanges(double radiusX, double radiusY, double intersect,
|
|
double start, double end)
|
|
{
|
|
var values = new List<double>
|
|
{
|
|
start,
|
|
end,
|
|
intersect,
|
|
180.0 - intersect,
|
|
180.0 + intersect,
|
|
360.0 - intersect,
|
|
360.0 + intersect,
|
|
540.0 - intersect,
|
|
540.0 + intersect,
|
|
720.0 - intersect
|
|
};
|
|
values.Sort();
|
|
var index = values.IndexOf(start);
|
|
var num2 = values.IndexOf(end);
|
|
if (num2 == index)
|
|
{
|
|
num2++;
|
|
}
|
|
else if (start < end)
|
|
{
|
|
IncreaseDuplicatedIndex(values, ref index);
|
|
DecreaseDuplicatedIndex(values, ref num2);
|
|
}
|
|
else if (start > end)
|
|
{
|
|
DecreaseDuplicatedIndex(values, ref index);
|
|
IncreaseDuplicatedIndex(values, ref num2);
|
|
}
|
|
|
|
var list = new List<double>();
|
|
if (index < num2)
|
|
for (var i = index; i <= num2; i++)
|
|
list.Add(values[i]);
|
|
else
|
|
for (var j = index; j >= num2; j--)
|
|
list.Add(values[j]);
|
|
var num5 = EnsureFirstQuadrant((list[0] + list[1]) / 2.0);
|
|
if (radiusX < radiusY && num5 < intersect || radiusX > radiusY && num5 > intersect)
|
|
list.RemoveAt(0);
|
|
if (list.Count % 2 == 1) list.RemoveLast();
|
|
if (list.Count == 0)
|
|
{
|
|
var num6 = Math.Min(index, num2) - 1;
|
|
if (num6 < 0) num6 = Math.Max(index, num2) + 1;
|
|
list.Add(values[num6]);
|
|
list.Add(values[num6]);
|
|
}
|
|
|
|
return list.ToArray();
|
|
}
|
|
|
|
protected override Rect ComputeLogicalBounds(Rect layoutBounds, IGeometrySourceParameters parameters)
|
|
{
|
|
return GeometryHelper.GetStretchBound(base.ComputeLogicalBounds(layoutBounds, parameters),
|
|
parameters.Stretch, new Size(1.0, 1.0));
|
|
}
|
|
|
|
private static IList<Point> ComputeOneInnerCurve(double start, double end, Rect bounds, double offset)
|
|
{
|
|
var num = bounds.Width / 2.0;
|
|
var num2 = bounds.Height / 2.0;
|
|
var point = bounds.Center();
|
|
start = start * 3.1415926535897931 / 180.0;
|
|
end = end * 3.1415926535897931 / 180.0;
|
|
var num3 = 0.17453292519943295;
|
|
var num4 = (int) Math.Ceiling(Math.Abs(end - start) / num3);
|
|
num4 = Math.Max(2, num4);
|
|
var list = new List<Point>(num4);
|
|
var list2 = new List<Vector>(num4);
|
|
var lhs = new Point();
|
|
var item = new Point();
|
|
var vector = new Vector();
|
|
var vector2 = new Vector();
|
|
var vector3 = new Vector();
|
|
var vector4 = new Vector();
|
|
for (var i = 0; i < num4; i++)
|
|
{
|
|
var a = MathHelper.Lerp(start, end, i / (double) (num4 - 1));
|
|
var num10 = Math.Sin(a);
|
|
var num11 = Math.Cos(a);
|
|
lhs.X = point.X + num * num10;
|
|
lhs.Y = point.Y - num2 * num11;
|
|
vector.X = num * num11;
|
|
vector.Y = num2 * num10;
|
|
vector2.X = -num2 * num10;
|
|
vector2.Y = num * num11;
|
|
var d = num2 * num2 * num10 * num10 + num * num * num11 * num11;
|
|
var num6 = Math.Sqrt(d);
|
|
var num7 = 2.0 * num10 * num11 * (num2 * num2 - num * num);
|
|
vector3.X = -num2 * num11;
|
|
vector3.Y = -num * num10;
|
|
item.X = lhs.X + offset * vector2.X / num6;
|
|
item.Y = lhs.Y + offset * vector2.Y / num6;
|
|
vector4.X = vector.X + offset / num6 * (vector3.X - 0.5 * vector2.X / d * num7);
|
|
vector4.Y = vector.Y + offset / num6 * (vector3.Y - 0.5 * vector2.Y / d * num7);
|
|
list.Add(item);
|
|
list2.Add(-vector4.Normalized());
|
|
}
|
|
|
|
var list3 = new List<Point>(num4 * 3 + 1)
|
|
{
|
|
list[0]
|
|
};
|
|
for (var j = 1; j < num4; j++)
|
|
{
|
|
lhs = list[j - 1];
|
|
item = list[j];
|
|
var num13 = GeometryHelper.Distance(lhs, item) / 3.0;
|
|
list3.Add(lhs + list2[j - 1] * num13);
|
|
list3.Add(item - list2[j] * num13);
|
|
list3.Add(item);
|
|
}
|
|
|
|
return list3;
|
|
}
|
|
|
|
private static void DecreaseDuplicatedIndex(IList<double> values, ref int index)
|
|
{
|
|
// ReSharper disable once CompareOfFloatsByEqualityOperator
|
|
while (index > 0 && values[index] == values[index - 1]) index--;
|
|
}
|
|
|
|
internal static double EnsureFirstQuadrant(double angle)
|
|
{
|
|
angle = Math.Abs(angle % 180.0);
|
|
if (angle <= 90.0) return angle;
|
|
return 180.0 - angle;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|
private static Size GetArcSize(Rect bound)
|
|
{
|
|
return new Size(bound.Width / 2.0, bound.Height / 2.0);
|
|
}
|
|
|
|
private static void IncreaseDuplicatedIndex(IList<double> values, ref int index)
|
|
{
|
|
// ReSharper disable once CompareOfFloatsByEqualityOperator
|
|
while (index < values.Count - 1 && values[index] == values[index + 1]) index++;
|
|
}
|
|
|
|
internal static double InnerCurveSelfIntersect(double radiusX, double radiusY, double thickness)
|
|
{
|
|
var angleA = 0.0;
|
|
var angleB = 1.5707963267948966;
|
|
var flag = radiusX <= radiusY;
|
|
var vector = new Vector();
|
|
while (!AreCloseEnough(angleA, angleB))
|
|
{
|
|
var d = (angleA + angleB) / 2.0;
|
|
var num4 = Math.Cos(d);
|
|
var num5 = Math.Sin(d);
|
|
vector.X = radiusY * num5;
|
|
vector.Y = radiusX * num4;
|
|
vector.Normalize();
|
|
if (flag)
|
|
{
|
|
var num6 = radiusX * num5 - vector.X * thickness;
|
|
if (num6 > 0.0)
|
|
angleB = d;
|
|
else if (num6 < 0.0) angleA = d;
|
|
}
|
|
else
|
|
{
|
|
var num7 = radiusY * num4 - vector.Y * thickness;
|
|
if (num7 < 0.0)
|
|
angleB = d;
|
|
else if (num7 > 0.0) angleA = d;
|
|
}
|
|
}
|
|
|
|
var num8 = (angleA + angleB) / 2.0;
|
|
if (AreCloseEnough(num8, 0.0)) return 0.0;
|
|
if (!AreCloseEnough(num8, 1.5707963267948966)) return num8 * 180.0 / 3.1415926535897931;
|
|
return 90.0;
|
|
}
|
|
|
|
private static double NormalizeAngle(double degree)
|
|
{
|
|
if (degree < 0.0 || degree > 360.0)
|
|
{
|
|
degree = degree % 360.0;
|
|
if (degree < 0.0) degree += 360.0;
|
|
}
|
|
|
|
return degree;
|
|
}
|
|
|
|
private void NormalizeThickness(IArcGeometrySourceParameters parameters)
|
|
{
|
|
var num = LogicalBounds.Width / 2.0;
|
|
var num2 = LogicalBounds.Height / 2.0;
|
|
var rhs = Math.Min(num, num2);
|
|
var arcThickness = parameters.ArcThickness;
|
|
if (parameters.ArcThicknessUnit == UnitType.Pixel)
|
|
arcThickness = MathHelper.SafeDivide(arcThickness, rhs, 0.0);
|
|
_relativeThickness = MathHelper.EnsureRange(arcThickness, 0.0, 1.0);
|
|
_absoluteThickness = rhs * _relativeThickness;
|
|
}
|
|
|
|
private bool SyncPieceWiseInnerCurves(PathFigure figure, int index, ref Point firstPoint,
|
|
params double[] angles)
|
|
{
|
|
var flag = false;
|
|
var length = angles.Length;
|
|
var logicalBounds = LogicalBounds;
|
|
var absoluteThickness = _absoluteThickness;
|
|
flag |= figure.Segments.EnsureListCount(index + length / 2, () => new PolyBezierSegment());
|
|
for (var i = 0; i < length / 2; i++)
|
|
{
|
|
var points = ComputeOneInnerCurve(angles[i * 2], angles[i * 2 + 1], logicalBounds,
|
|
absoluteThickness);
|
|
if (i == 0) firstPoint = points[0];
|
|
flag |= PathSegmentHelper.SyncPolyBezierSegment(figure.Segments, index + i, points, 1,
|
|
points.Count - 1);
|
|
}
|
|
|
|
return flag;
|
|
}
|
|
|
|
[SuppressMessage("ReSharper", "ConditionIsAlwaysTrueOrFalse")]
|
|
[SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
|
|
protected override bool UpdateCachedGeometry(IArcGeometrySourceParameters parameters)
|
|
{
|
|
var flag = false;
|
|
NormalizeThickness(parameters);
|
|
var relativeMode = parameters.ArcThicknessUnit == UnitType.Percent;
|
|
var flag3 = MathHelper.AreClose(parameters.StartAngle, parameters.EndAngle);
|
|
var angle = NormalizeAngle(parameters.StartAngle);
|
|
var end = NormalizeAngle(parameters.EndAngle);
|
|
if (end < angle) end += 360.0;
|
|
var isFilled = _relativeThickness == 1.0;
|
|
var flag5 = _relativeThickness == 0.0;
|
|
if (flag3) return flag | UpdateZeroAngleGeometry(relativeMode, angle);
|
|
if (MathHelper.IsVerySmall((end - angle) % 360.0))
|
|
{
|
|
if (flag5 || isFilled) return flag | UpdateEllipseGeometry(isFilled);
|
|
return flag | UpdateFullRingGeometry(relativeMode);
|
|
}
|
|
|
|
if (isFilled) return flag | UpdatePieGeometry(angle, end);
|
|
if (flag5) return flag | UpdateOpenArcGeometry(angle, end);
|
|
return flag | UpdateRingArcGeometry(relativeMode, angle, end);
|
|
}
|
|
|
|
private bool UpdateEllipseGeometry(bool isFilled)
|
|
{
|
|
var flag = false;
|
|
var y = MathHelper.Lerp(LogicalBounds.Top, LogicalBounds.Bottom, 0.5);
|
|
var point = new Point(LogicalBounds.Left, y);
|
|
var point2 = new Point(LogicalBounds.Right, y);
|
|
flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
|
|
() => new PathGeometry());
|
|
flag |= geometry.Figures.EnsureListCount(1, () => new PathFigure());
|
|
var dependencyObject = geometry.Figures[0];
|
|
flag |= dependencyObject.SetIfDifferent(PathFigure.IsClosedProperty, true);
|
|
flag |= dependencyObject.SetIfDifferent(PathFigure.IsFilledProperty, isFilled);
|
|
flag |= dependencyObject.Segments.EnsureListCount(2, () => new ArcSegment());
|
|
flag |= dependencyObject.SetIfDifferent(PathFigure.StartPointProperty, point);
|
|
flag |= GeometryHelper.EnsureSegmentType(out var segment, dependencyObject.Segments, 0,
|
|
() => new ArcSegment());
|
|
flag |= GeometryHelper.EnsureSegmentType(out var segment2, dependencyObject.Segments, 1,
|
|
() => new ArcSegment());
|
|
var size = new Size(LogicalBounds.Width / 2.0, LogicalBounds.Height / 2.0);
|
|
flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, false);
|
|
flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, size);
|
|
flag |= segment.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
|
|
flag |= segment.SetIfDifferent(ArcSegment.PointProperty, point2);
|
|
flag |= segment2.SetIfDifferent(ArcSegment.IsLargeArcProperty, false);
|
|
flag |= segment2.SetIfDifferent(ArcSegment.SizeProperty, size);
|
|
flag |= segment2.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
|
|
return flag | segment2.SetIfDifferent(ArcSegment.PointProperty, point);
|
|
}
|
|
|
|
private bool UpdateFullRingGeometry(bool relativeMode)
|
|
{
|
|
var flag = false;
|
|
flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
|
|
() => new PathGeometry());
|
|
flag |= geometry.SetIfDifferent(PathGeometry.FillRuleProperty, FillRule.EvenOdd);
|
|
flag |= geometry.Figures.EnsureListCount(2, () => new PathFigure());
|
|
flag |= PathFigureHelper.SyncEllipseFigure(geometry.Figures[0], LogicalBounds,
|
|
SweepDirection.Clockwise);
|
|
var logicalBounds = LogicalBounds;
|
|
var num = logicalBounds.Width / 2.0;
|
|
var num2 = logicalBounds.Height / 2.0;
|
|
if (relativeMode || MathHelper.AreClose(num, num2))
|
|
{
|
|
var bounds = LogicalBounds.Resize(1.0 - _relativeThickness);
|
|
return flag | PathFigureHelper.SyncEllipseFigure(geometry.Figures[1], bounds,
|
|
SweepDirection.Counterclockwise);
|
|
}
|
|
|
|
flag |= geometry.Figures[1].SetIfDifferent(PathFigure.IsClosedProperty, true);
|
|
flag |= geometry.Figures[1].SetIfDifferent(PathFigure.IsFilledProperty, true);
|
|
var firstPoint = new Point();
|
|
var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
|
|
var angles = ComputeAngleRanges(num, num2, intersect, 360.0, 0.0);
|
|
flag |= SyncPieceWiseInnerCurves(geometry.Figures[1], 0, ref firstPoint, angles);
|
|
return flag | geometry.Figures[1].SetIfDifferent(PathFigure.StartPointProperty, firstPoint);
|
|
}
|
|
|
|
private bool UpdateOpenArcGeometry(double start, double end)
|
|
{
|
|
PathFigure figure;
|
|
ArcSegment segment;
|
|
var flag = false;
|
|
var cachedGeometry = CachedGeometry as PathGeometry;
|
|
if (cachedGeometry == null || cachedGeometry.Figures.Count != 1 ||
|
|
(figure = cachedGeometry.Figures[0]).Segments.Count != 1 ||
|
|
(segment = figure.Segments[0] as ArcSegment) == null)
|
|
{
|
|
figure = new PathFigure();
|
|
CachedGeometry = new PathGeometry
|
|
{
|
|
Figures = {figure}
|
|
};
|
|
figure.Segments.Add(segment = new ArcSegment());
|
|
figure.IsClosed = false;
|
|
segment.SweepDirection = SweepDirection.Clockwise;
|
|
flag = true;
|
|
}
|
|
|
|
flag |= figure.SetIfDifferent(PathFigure.StartPointProperty,
|
|
GeometryHelper.GetArcPoint(start, LogicalBounds));
|
|
flag |= figure.SetIfDifferent(PathFigure.IsFilledProperty, false);
|
|
flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
|
|
GeometryHelper.GetArcPoint(end, LogicalBounds));
|
|
flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(LogicalBounds));
|
|
return flag | segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
|
|
}
|
|
|
|
private bool UpdatePieGeometry(double start, double end)
|
|
{
|
|
PathFigure figure;
|
|
ArcSegment segment;
|
|
LineSegment segment2;
|
|
var flag = false;
|
|
var cachedGeometry = CachedGeometry as PathGeometry;
|
|
if (cachedGeometry == null || cachedGeometry.Figures.Count != 1 ||
|
|
(figure = cachedGeometry.Figures[0]).Segments.Count != 2 ||
|
|
(segment = figure.Segments[0] as ArcSegment) == null ||
|
|
(segment2 = figure.Segments[1] as LineSegment) == null)
|
|
{
|
|
figure = new PathFigure();
|
|
CachedGeometry = new PathGeometry
|
|
{
|
|
Figures = {figure}
|
|
};
|
|
figure.Segments.Add(segment = new ArcSegment());
|
|
figure.Segments.Add(segment2 = new LineSegment());
|
|
figure.IsClosed = true;
|
|
segment.SweepDirection = SweepDirection.Clockwise;
|
|
flag = true;
|
|
}
|
|
|
|
flag |= figure.SetIfDifferent(PathFigure.StartPointProperty,
|
|
GeometryHelper.GetArcPoint(start, LogicalBounds));
|
|
flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
|
|
GeometryHelper.GetArcPoint(end, LogicalBounds));
|
|
flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(LogicalBounds));
|
|
flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
|
|
return flag | segment2.SetIfDifferent(LineSegment.PointProperty, LogicalBounds.Center());
|
|
}
|
|
|
|
private bool UpdateRingArcGeometry(bool relativeMode, double start, double end)
|
|
{
|
|
var flag = false;
|
|
flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
|
|
() => new PathGeometry());
|
|
flag |= geometry.SetIfDifferent(PathGeometry.FillRuleProperty, FillRule.Nonzero);
|
|
flag |= geometry.Figures.EnsureListCount(1, () => new PathFigure());
|
|
var dependencyObject = geometry.Figures[0];
|
|
flag |= dependencyObject.SetIfDifferent(PathFigure.IsClosedProperty, true);
|
|
flag |= dependencyObject.SetIfDifferent(PathFigure.IsFilledProperty, true);
|
|
flag |= dependencyObject.SetIfDifferent(PathFigure.StartPointProperty,
|
|
GeometryHelper.GetArcPoint(start, LogicalBounds));
|
|
flag |= dependencyObject.Segments.EnsureListCountAtLeast(3, () => new ArcSegment());
|
|
flag |= GeometryHelper.EnsureSegmentType(out var segment, dependencyObject.Segments, 0,
|
|
() => new ArcSegment());
|
|
flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
|
|
GeometryHelper.GetArcPoint(end, LogicalBounds));
|
|
flag |= segment.SetIfDifferent(ArcSegment.SizeProperty,
|
|
new Size(LogicalBounds.Width / 2.0, LogicalBounds.Height / 2.0));
|
|
flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
|
|
flag |= segment.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
|
|
flag |= GeometryHelper.EnsureSegmentType(out var segment2, dependencyObject.Segments, 1,
|
|
() => new LineSegment());
|
|
var logicalBounds = LogicalBounds;
|
|
var num = logicalBounds.Width / 2.0;
|
|
var num2 = logicalBounds.Height / 2.0;
|
|
if (relativeMode || MathHelper.AreClose(num, num2))
|
|
{
|
|
var bound = LogicalBounds.Resize(1.0 - _relativeThickness);
|
|
flag |= segment2.SetIfDifferent(LineSegment.PointProperty,
|
|
GeometryHelper.GetArcPoint(end, bound));
|
|
flag |= dependencyObject.Segments.EnsureListCount(3, () => new ArcSegment());
|
|
flag |= GeometryHelper.EnsureSegmentType(out var segment3, dependencyObject.Segments, 2,
|
|
() => new ArcSegment());
|
|
flag |= segment3.SetIfDifferent(ArcSegment.PointProperty,
|
|
GeometryHelper.GetArcPoint(start, bound));
|
|
flag |= segment3.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(bound));
|
|
flag |= segment3.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
|
|
return flag | segment3.SetIfDifferent(ArcSegment.SweepDirectionProperty,
|
|
SweepDirection.Counterclockwise);
|
|
}
|
|
|
|
var firstPoint = new Point();
|
|
var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
|
|
var angles = ComputeAngleRanges(num, num2, intersect, end, start);
|
|
flag |= SyncPieceWiseInnerCurves(dependencyObject, 2, ref firstPoint, angles);
|
|
return flag | segment2.SetIfDifferent(LineSegment.PointProperty, firstPoint);
|
|
}
|
|
|
|
private bool UpdateZeroAngleGeometry(bool relativeMode, double angle)
|
|
{
|
|
Point point2;
|
|
var flag = false;
|
|
var arcPoint = GeometryHelper.GetArcPoint(angle, LogicalBounds);
|
|
var logicalBounds = LogicalBounds;
|
|
var num = logicalBounds.Width / 2.0;
|
|
var num2 = logicalBounds.Height / 2.0;
|
|
if (relativeMode || MathHelper.AreClose(num, num2))
|
|
{
|
|
var bound = LogicalBounds.Resize(1.0 - _relativeThickness);
|
|
point2 = GeometryHelper.GetArcPoint(angle, bound);
|
|
}
|
|
else
|
|
{
|
|
var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
|
|
var numArray = ComputeAngleRanges(num, num2, intersect, angle, angle);
|
|
var a = numArray[0] * 3.1415926535897931 / 180.0;
|
|
var vector = new Vector(num2 * Math.Sin(a), -num * Math.Cos(a));
|
|
point2 = GeometryHelper.GetArcPoint(numArray[0], LogicalBounds) -
|
|
vector.Normalized() * _absoluteThickness;
|
|
}
|
|
|
|
flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
|
|
() => new LineGeometry());
|
|
flag |= geometry.SetIfDifferent(LineGeometry.StartPointProperty, arcPoint);
|
|
return flag | geometry.SetIfDifferent(LineGeometry.EndPointProperty, point2);
|
|
}
|
|
}
|
|
} |