Esempio n. 1
0
    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));
    }
Esempio n. 2
0
    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));
    }
Esempio n. 3
0
 /// <summary>
 /// Asserts whether dictionary of double values are close.
 /// </summary>
 /// <param name="expected">The expected.</param>
 /// <param name="actual">The actual.</param>
 /// <param name="epsilon">The epsilon.</param>
 public static void DictionaryAreClose(Dictionary <double, double> expected, Dictionary <double, double> actual, double epsilon = 1e-5)
 {
     Assert.AreEqual(expected.Count, actual.Count, "Dictionary count are not equal.");
     foreach (var value in actual)
     {
         var dictkey = expected.Keys.First(x => MathHelper.AreClose(x, value.Key));
         AreClose(expected[dictkey], value.Value, epsilon);
     }
 }
Esempio n. 4
0
    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));
    }
Esempio n. 5
0
    protected override double[] InterpolateValueCore(double[] baseValue, double keyFrameProgress)
    {
        if (MathHelper.IsVerySmall(keyFrameProgress))
        {
            return(baseValue);
        }

        if (MathHelper.AreClose(keyFrameProgress, 1))
        {
            return(Numbers);
        }

        return(AnimationHelper.InterpolateGeometryValue(baseValue, Numbers, keyFrameProgress));
    }
        private void SetDefaultValues()
        {
            if (this.Minimum > this.Maximum)
            {
                this.Minimum = this.Maximum;
            }

            if (MathHelper.AreClose(this.Minimum, this.Maximum))
            {
                this.Maximum += Epsilon;
            }

            if (!this.isMaximumValueSet)
            {
                this.SelectedMaximum = this.Maximum;
            }

            if (!this.isMinimumValueSet)
            {
                this.SelectedMinimum = this.Minimum;
            }

            if (this.SelectedMinimum < this.Minimum)
            {
                this.SelectedMinimum = this.Minimum;
            }

            if (this.SelectedMaximum < this.Minimum)
            {
                this.SelectedMaximum = this.Minimum;
            }

            if (this.SelectedMinimum > this.Maximum)
            {
                this.SelectedMinimum = this.Maximum;
            }

            if (this.SelectedMaximum > this.Maximum)
            {
                this.SelectedMaximum = this.Maximum;
            }

            if (this.SelectedMaximum < this.SelectedMinimum)
            {
                this.SelectedMinimum = this.SelectedMaximum;
            }
        }
Esempio n. 7
0
    public static double RoundLayoutValue(double value, double dpiScale)
    {
        double newValue;

        if (!MathHelper.AreClose(dpiScale, 1.0))
        {
            newValue = Math.Round(value * dpiScale) / dpiScale;
            if (double.IsNaN(newValue) || double.IsInfinity(newValue) || MathHelper.AreClose(newValue, double.MaxValue))
            {
                newValue = value;
            }
        }
        else
        {
            newValue = Math.Round(value);
        }

        return(newValue);
    }
Esempio n. 8
0
    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));
    }
Esempio n. 9
0
 public static bool IsUniform(this Thickness thickness) =>
 MathHelper.AreClose(thickness.Left, thickness.Top) &&
 MathHelper.AreClose(thickness.Left, thickness.Right) &&
 MathHelper.AreClose(thickness.Left, thickness.Bottom);
Esempio n. 10
0
 /// <summary>
 /// Asserts whether double values are close.
 /// </summary>
 /// <param name="expected">The expected.</param>
 /// <param name="actual">The actual.</param>
 /// <param name="epsilon">The epsilon.</param>
 public static void AreClose(double expected, double actual, double epsilon = 1e-5)
 {
     Assert.IsTrue(MathHelper.AreClose(expected, actual, epsilon), "Values are not close.\r\n Expected<{0}>. Actual<{1}>", expected, actual);
 }