Refactor 3

Author: 0x5bfa

src/Files.App.Controls/Storage/RingShape/RingShape.Properties.cs

@@ -24,14 +24,14 @@ public partial class RingShape : Path
 		protected virtual void OnStartAngleChanged(double oldValue, double newValue)
 		{
 			BeginUpdate();
-			StartAngle = ValidateAngle(StartAngle);
+			ValidateAngle();
 			EndUpdate();
 		}
 
 		protected virtual void OnEndAngleChanged(double oldValue, double newValue)
 		{
 			BeginUpdate();
-			EndAngle = ValidateAngle(EndAngle);
+			ValidateAngle();
 			EndUpdate();
 		}
 
@@ -44,28 +44,28 @@ protected virtual void OnSweepDirectionChanged(SweepDirection oldValue, SweepDir
 		protected virtual void OnMinAngleChanged(double oldValue, double newValue)
 		{
 			BeginUpdate();
-			CalculateAndSetNormalizedAngles();
+			CalculateNormalizedAngles();
 			EndUpdate();
 		}
 
 		protected virtual void OnMaxAngleChanged(double oldValue, double newValue)
 		{
 			BeginUpdate();
-			CalculateAndSetNormalizedAngles();
+			CalculateNormalizedAngles();
 			EndUpdate();
 		}
 
 		protected virtual void OnRadiusWidthChanged(double oldValue, double newValue)
 		{
 			BeginUpdate();
-			AdjustRadiusWidth();
+			ValidateRadius();
 			EndUpdate();
 		}
 
 		protected virtual void OnRadiusHeightChanged(double oldValue, double newValue)
 		{
 			BeginUpdate();
-			AdjustRadiusHeight();
+			ValidateRadius();
 			EndUpdate();
 		}
 

src/Files.App.Controls/Storage/RingShape/RingShape.cs

@@ -25,10 +25,6 @@ public partial class RingShape : Path
 		private double			_equalRadius;            // Calculated where RadiusWidth and RadiusHeight are equal
 		private double			_normalizedMinAngle;     // Normalized MinAngle between -180 and 540
 		private double			_normalizedMaxAngle;     // Normalized MaxAngle between 0 and 360
-		private double			_validStartAngle;        // The validated StartAngle
-		private double			_validEndAngle;          // The validated EndAngle
-		private double			_radiusWidth;            // The radius Width
-		private double			_radiusHeight;           // The radius Height
 
 		// Constructor
 
@@ -64,53 +60,38 @@ private void UpdatePath()
 		{
 			if (_isUpdating ||
 				ActualWidth <= 0 || ActualHeight <= 0 ||
-				_radiusWidth <= 0 || _radiusHeight <= 0)
+				RadiusWidth <= 0 || RadiusHeight <= 0)
 				return;
 
-			UpdateSizeAndStroke(this);
-
-			var startAngle = _validStartAngle;
-			var endAngle = _validEndAngle;
+			UpdateSizeAndStroke();
 
 			// If the ring is closed and complete
-			if (endAngle >= startAngle + 360)
+			if (EndAngle >= StartAngle + 360)
 			{
-				Data = DrawEllipse(IsCircle, Center, _equalRadius, _radiusWidth, _radiusHeight);
+				Data = DrawEllipse();
 			}
 			else
 			{
-				this.InvalidateArrange();
-				this.Data = DrawArc(this, SweepDirection, IsCircle, Center, startAngle, endAngle, _equalRadius, _radiusWidth, _radiusHeight);
+				InvalidateArrange();
+				Data = DrawArc();
 			}
 		}
 
 		#endregion
 
 		#region Drawing Updates
 
-		/// <summary>
-		/// Updates sizes, center point and radii
-		/// </summary>
-		/// <param name="d">The DependencyObject calling the function</param>
-		public void UpdateSizeAndStroke(DependencyObject d)
+		public void UpdateSizeAndStroke()
 		{
-			RingShape ringShape = (RingShape)d;
-
-			AdjustRadiusWidth();
-			AdjustRadiusHeight();
-
-			_equalSize = CalculateEqualSize(new(Width, Height));
-			_equalRadius = CalculateEqualRadius();
-
-			Center = new ( ringShape.Width / 2 , ringShape.Height / 2 );
-
-			CalculateAndSetNormalizedAngles();
-
-			_validStartAngle = ValidateAngle(StartAngle);
-			_validEndAngle = ValidateAngle(EndAngle);
+			ValidateRadius();
+			CalculateEqualSize(new(Width, Height));
+			CalculateEqualRadius();
+			Center = new(Width / 2.0, Height / 2.0);
+			CalculateNormalizedAngles();
+			ValidateAngles();
 		}
 
-		private static EllipseGeometry DrawEllipse(bool IsCircle, Point Center, double EqualRadius, double RadiusWidth, double RadiusHeight)
+		private EllipseGeometry DrawEllipse()
 		{
 			EllipseGeometry eg;
 
@@ -119,62 +100,55 @@ private static EllipseGeometry DrawEllipse(bool IsCircle, Point Center, double E
 				eg = new()
 				{
 					Center = Center,
-					RadiusX = EqualRadius,
-					RadiusY = EqualRadius,
+					RadiusX = _equalRadius,
+					RadiusY = _equalRadius,
 				};
 			}
 			else
 			{
 				eg = new()
 				{
 					Center = Center,
-					RadiusX = RadiusWidth,
-					RadiusY = RadiusHeight,
+					RadiusX = _equalRadius,
+					RadiusY = _equalRadius,
 				};
 			}
 
 			return eg;
 		}
 
-		private static PathGeometry DrawArc(RingShape RingShape, SweepDirection SweepDirection, bool IsCircle, Point Center, double StartAngle, double EndAngle, double EqualRadius, double RadiusWidth, double RadiusHeight)
+		private PathGeometry DrawArc()
 		{
+			var newCenter = Center;
+			var arcSegment = new ArcSegment();
 			var pathGeometry = new PathGeometry();
 			var pathFigure = new PathFigure()
 			{
-				pathFigure.IsClosed = false,
-				pathFigure.IsFilled = false,
+				IsClosed = false,
+				IsFilled = false,
 			};
 
-			var newCenter = Center;
-			var arcSegment = new ArcSegment();
-
 			if (IsCircle)
 			{
-				var radius = EqualRadius;
-
-				RingShape.ActualRadiusWidth = radius;
-				RingShape.ActualRadiusHeight = radius;
+				ActualRadiusWidth = _equalRadius;
+				ActualRadiusHeight = _equalRadius;
 
 				// Start Point
-				pathFigure.StartPoint = ArcStartPoint( SweepDirection , newCenter, StartAngle, radius, radius);
+				pathFigure.StartPoint = ArcStartPoint();
 
 				// Arc Segment and End Point
-				arcSegment = CreateArcSegment( SweepDirection , newCenter , StartAngle , EndAngle , radius , radius );
+				arcSegment = CreateArcSegment();
 			}
 			else
 			{
-				var radiusWidth = RadiusWidth;
-				var radiusHeight = RadiusHeight;
-
-				RingShape.ActualRadiusWidth = radiusWidth;
-				RingShape.ActualRadiusHeight = radiusHeight;
+				ActualRadiusWidth = RadiusWidth;
+				ActualRadiusHeight = RadiusHeight;
 
 				// Start Point
-				pathFigure.StartPoint = ArcStartPoint( SweepDirection , newCenter , StartAngle , radiusWidth , radiusHeight );
-
+				pathFigure.StartPoint = ArcStartPoint();
 
 				// Arc Segment and End Point
-				arcSegment = CreateArcSegment( SweepDirection , newCenter , StartAngle , EndAngle , radiusWidth , radiusHeight );
+				arcSegment = CreateArcSegment();
 			}
 
 			pathFigure.Segments.Add(arcSegment);
@@ -183,18 +157,18 @@ private static PathGeometry DrawArc(RingShape RingShape, SweepDirection SweepDir
 			return pathGeometry;
 		}
 
-		private static Point ArcStartPoint(SweepDirection SweepDirection , Point Center, double StartAngle , double RadiusWidth, double RadiusHeight)
+		private Point ArcStartPoint()
 		{
 			return SweepDirection is SweepDirection.Counterclockwise
 				? new(
 					Center.X - Math.Sin(StartAngle * DegreesToRadians ) * RadiusWidth,
-					Center.Y - Math.Cos(StartAngle * DegreesToRadians ) * RadiusHeight);
+					Center.Y - Math.Cos(StartAngle * DegreesToRadians ) * RadiusHeight)
 				: new(
-					Center.X + Math.Sin(StartAngle * DegreesToRadians) * RadiusWidth ,
+					Center.X + Math.Sin(StartAngle * DegreesToRadians) * RadiusWidth,
 					Center.Y - Math.Cos(StartAngle * DegreesToRadians) * RadiusHeight);
 		}
 
-		private static ArcSegment CreateArcSegment(SweepDirection SweepDirection , Point Center , double StartAngle, double EndAngle , double RadiusWidth , double RadiusHeight)
+		private ArcSegment CreateArcSegment()
 		{ 
 			var finalArcSegment = new ArcSegment();
 
@@ -237,7 +211,7 @@ private static ArcSegment CreateArcSegment(SweepDirection SweepDirection , Point
 				}
 			}
 
-			finalArcSegment.Size = new(RadiusWidth , RadiusHeight);
+			finalArcSegment.Size = new(RadiusWidth, RadiusHeight);
 
 			return finalArcSegment;
 		}
@@ -246,33 +220,25 @@ private static ArcSegment CreateArcSegment(SweepDirection SweepDirection , Point
 
 		#region Value Calculations
 
-		private static Size CalculateEqualSize(Size size)
+		private Size CalculateEqualSize(Size size)
 		{
 			var smaller = Math.Min(size.Width, size.Height);
-			if (smaller > StrokeThickness * 2)
-				return new(smaller, smaller);
-			else
-				return new(StrokeThickness * 2, StrokeThickness * 2);
+			_equalSize = smaller > StrokeThickness * 2
+				? new(smaller, smaller);
+				: new(StrokeThickness * 2, StrokeThickness * 2);
 		}
 
-		private static double CalculateEqualRadius()
+		private double CalculateEqualRadius()
 		{
 			var smaller = Math.Min(RadiusWidth, RadiusHeight);
-			if (smaller <= StrokeThickness)
-				return StrokeThickness;
-			else if (smaller >= ((_equalSize.Width / 2) - (StrokeThickness / 2)))
-				return (_equalSize.Width / 2.0) - (StrokeThickness / 2.0);
-			else
-				return smaller;
+			_equalRadius = smaller <= StrokeThickness
+				? StrokeThickness
+				: smaller >= ((_equalSize.Width / 2.0) - (StrokeThickness / 2.0))
+					? (_equalSize.Width / 2.0) - (StrokeThickness / 2.0)
+					: smaller;
 		}
 
-		private static Point CalculateCenter(double Width, double Height)
-		{
-			var calculatedCenter = new Point((Width / 2.0), (Height / 2.0));
-			return calculatedCenter;
-		}
-
-		private static void CalculateAndSetNormalizedAngles()
+		private void CalculateNormalizedAngles()
 		{
 			var result = CalculateModulus(MinAngle, 360);
 			if (result >= 180)
@@ -290,50 +256,49 @@ private static void CalculateAndSetNormalizedAngles()
 			_normalizedMaxAngle = result;
 		}
 
-		private static double CalculateModulus(double number, double divider)
+		private double CalculateModulus(double number, double divider)
 		{
 			// Calculate the modulus
 			var result = number % divider;
 
 			// Ensure the result is positive or zero
-			result = result < 0 ? result + divider : result;
+			result = result < 0.0 ? result + divider : result;
 
 			return result;
 		}
 
-		private double ValidateAngle(double angle)
+		private double ValidateAngles()
 		{
-			return angle >= _normalizedMaxAngle
+			MinAngle = MinAngle >= _normalizedMaxAngle
 				? _normalizedMaxAngle
-				: angle <= _normalizedMinAngle
+				: MinAngle <= _normalizedMinAngle
 					? _normalizedMinAngle
-					: angle;
-		}
+					: MinAngle;
 
-		private void AdjustRadiusWidth()
-		{
-			var maxValue = (Width / 2) - (StrokeThickness / 2);
-			var threshold = StrokeThickness;
-
-			if (RadiusWidth >= maxValue)
-				RadiusWidth = maxValue;
-			else if (RadiusWidth <= maxValue && RadiusWidth >= threshold)
-				RadiusWidth = RadiusWidth;
-			else
-				RadiusWidth = threshold;
+			MaxAngle = MaxAngle >= _normalizedMaxAngle
+				? _normalizedMaxAngle
+				: MaxAngle <= _normalizedMinAngle
+					? _normalizedMinAngle
+					: MaxAngle;
 		}
 
-		private void AdjustRadiusHeight()
+		private void ValidateRadius()
 		{
-			var maxValue = (Height / 2) - (StrokeThickness / 2);
+			var maxWidthValue = (Width / 2.0) - (StrokeThickness / 2.0);
+			var maxHeightValue = (Height / 2.0) - (StrokeThickness / 2.0);
 			var threshold = StrokeThickness;
 
-			if (RadiusHeight >= maxValue)
-				RadiusHeight = maxValue;
-			else if (RadiusHeight <= maxValue && RadiusHeight >= threshold)
-				RadiusHeight = RadiusHeight;
-			else
-				RadiusHeight = threshold;
+			RadiusWidth = RadiusWidth >= maxWidthValue
+				? maxWidthValue
+				: RadiusWidth <= maxWidthValue && RadiusWidth >= threshold
+					? RadiusWidth
+					: threshold;
+
+			RadiusHeight = RadiusHeight >= maxHeightValue
+				? maxHeightValue
+				: RadiusHeight <= maxHeightValue && RadiusHeight >= threshold
+					? RadiusHeight
+					: threshold;
 		}
 
 		#endregion