Refactor 1

Author: 0x5bfa

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

@@ -38,7 +38,6 @@ protected virtual void OnEndAngleChanged(double oldValue, double newValue)
 		protected virtual void OnSweepDirectionChanged(SweepDirection oldValue, SweepDirection newValue)
 		{
 			BeginUpdate();
-			_sweepDirection = SweepDirection;
 			EndUpdate();
 		}
 
@@ -73,7 +72,6 @@ protected virtual void OnRadiusHeightChanged(double oldValue, double newValue)
 		protected virtual void OnIsCircleChanged(bool oldValue, bool newValue)
 		{
 			BeginUpdate();
-			_isCircle = IsCircle;
 			EndUpdate();
 		}
 	}

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

@@ -21,17 +21,14 @@ public partial class RingShape : Path
 		// Fields
 
 		private bool			_isUpdating;             // Is True when path is updating
-		private bool			_isCircle;               // When True, Width and Height are equalized
 		private Size			_equalSize;              // Calculated where Width and Height are equal
 		private double			_equalRadius;            // Calculated where RadiusWidth and RadiusHeight are equal
-		private Point			_centerPoint;            // Center Point within Width and Height bounds
 		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
-		private SweepDirection	_sweepDirection;         // The SweepDirection
 
 		// Constructor
 
@@ -94,12 +91,12 @@ private void UpdatePath()
 			// If the ring is closed and complete
 			if (endAngle >= startAngle + 360)
 			{
-				Data = DrawEllipse(_isCircle, _centerPoint, _equalRadius, _radiusWidth, _radiusHeight);
+				Data = DrawEllipse(IsCircle, Center, _equalRadius, _radiusWidth, _radiusHeight);
 			}
 			else
 			{
 				this.InvalidateArrange();
-				this.Data = DrawArc(this, _sweepDirection, _isCircle, _centerPoint, startAngle, endAngle, _equalRadius, _radiusWidth, _radiusHeight);
+				this.Data = DrawArc(this, SweepDirection, IsCircle, Center, startAngle, endAngle, _equalRadius, _radiusWidth, _radiusHeight);
 			}
 		}
 
@@ -115,19 +112,18 @@ public void UpdateSizeAndStroke(DependencyObject d)
 		{
 			RingShape ringShape = (RingShape)d;
 
-			AdjustRadiusWidth( ringShape , ringShape.RadiusWidth , ringShape.StrokeThickness );
-			AdjustRadiusHeight( ringShape , ringShape.RadiusHeight , ringShape.StrokeThickness );
+			AdjustRadiusWidth();
+			AdjustRadiusHeight();
 
-			_equalSize = CalculateEqualSize( new Size( ringShape.Width , ringShape.Height ) , ringShape.StrokeThickness );
-			_equalRadius = CalculateEqualRadius( ringShape , ringShape.RadiusWidth , ringShape.RadiusHeight , ringShape.StrokeThickness );
+			_equalSize = CalculateEqualSize(new(Width, Height));
+			_equalRadius = CalculateEqualRadius();
 
-			_centerPoint = new Point( ringShape.Width / 2 , ringShape.Height / 2 );
-			ringShape.Center = _centerPoint;
+			Center = new ( ringShape.Width / 2 , ringShape.Height / 2 );
 
-			CalculateAndSetNormalizedAngles( ringShape , ringShape.MinAngle , ringShape.MaxAngle );
+			CalculateAndSetNormalizedAngles();
 
-			ValidateAngle( ringShape , ringShape.StartAngle , true );
-			ValidateAngle( ringShape , ringShape.EndAngle , false );
+			_validStartAngle = ValidateAngle(StartAngle);
+			_validEndAngle = ValidateAngle(EndAngle);
 		}
 
 		private static EllipseGeometry DrawEllipse(bool IsCircle, Point Center, double EqualRadius, double RadiusWidth, double RadiusHeight)
@@ -161,8 +157,8 @@ private static PathGeometry DrawArc(RingShape RingShape, SweepDirection SweepDir
 			var pathGeometry = new PathGeometry();
 			var pathFigure = new PathFigure()
 			{
-				pathFigure.IsClosed = false;
-				pathFigure.IsFilled = false;
+				pathFigure.IsClosed = false,
+				pathFigure.IsFilled = false,
 			};
 
 			var newCenter = Center;
@@ -178,7 +174,6 @@ private static PathGeometry DrawArc(RingShape RingShape, SweepDirection SweepDir
 				// Start Point
 				pathFigure.StartPoint = ArcStartPoint( SweepDirection , newCenter, StartAngle, radius, radius);
 
-
 				// Arc Segment and End Point
 				arcSegment = CreateArcSegment( SweepDirection , newCenter , StartAngle , EndAngle , radius , radius );
 			}
@@ -206,35 +201,23 @@ private static PathGeometry DrawArc(RingShape RingShape, SweepDirection SweepDir
 
 		private static Point ArcStartPoint(SweepDirection SweepDirection , Point Center, double StartAngle , double RadiusWidth, double RadiusHeight)
 		{
-			var finalPoint = new Point();
-
-			// Counterclockwise
-			if ( SweepDirection is SweepDirection.Counterclockwise)
-			{
-				finalPoint = new(
+			return SweepDirection is SweepDirection.Counterclockwise
+				? new(
 					Center.X - Math.Sin(StartAngle * DegreesToRadians ) * RadiusWidth,
 					Center.Y - Math.Cos(StartAngle * DegreesToRadians ) * RadiusHeight);
-			}
-			// Clockwise
-			else
-			{
-				finalPoint = new(
+				: new(
 					Center.X + Math.Sin(StartAngle * DegreesToRadians) * RadiusWidth ,
 					Center.Y - Math.Cos(StartAngle * DegreesToRadians) * RadiusHeight);
-			}
-
-			return finalPoint;
 		}
 
 		private static ArcSegment CreateArcSegment(SweepDirection SweepDirection , Point Center , double StartAngle, double EndAngle , double RadiusWidth , double RadiusHeight)
 		{ 
 			var finalArcSegment = new ArcSegment();
 
-			// Counterclockwise
 			if (SweepDirection is SweepDirection.Counterclockwise)
 			{
 				finalArcSegment.Point =
-					new Point(
+					new(
 						Center.X - Math.Sin(EndAngle * DegreesToRadians) * RadiusWidth,
 						Center.Y - Math.Cos(EndAngle * DegreesToRadians) * RadiusHeight);
 
@@ -249,11 +232,10 @@ private static ArcSegment CreateArcSegment(SweepDirection SweepDirection , Point
 					finalArcSegment.SweepDirection = SweepDirection.Counterclockwise;
 				}
 			}
-			// Clockwise
 			else
 			{
 				finalArcSegment.Point =
-					new Point(
+					new(
 						Center.X + Math.Sin(EndAngle * DegreesToRadians) * RadiusWidth,
 						Center.Y - Math.Cos(EndAngle * DegreesToRadians) * RadiusHeight);
 
@@ -280,31 +262,22 @@ private static ArcSegment CreateArcSegment(SweepDirection SweepDirection , Point
 
 		#region Value Calculations
 
-		private static Size CalculateEqualSize(Size size, double strokeThickness)
+		private static Size CalculateEqualSize(Size size)
 		{
-			var adjWidth = size.Width;
-			var adjHeight = size.Height;
-
-			var smaller = Math.Min(adjWidth, adjHeight);
-			if (smaller > strokeThickness * 2)
+			var smaller = Math.Min(size.Width, size.Height);
+			if (smaller > StrokeThickness * 2)
 				return new(smaller, smaller);
 			else
-				return new(strokeThickness * 2, strokeThickness * 2);
+				return new(StrokeThickness * 2, StrokeThickness * 2);
 		}
 
-		private static double CalculateEqualRadius(DependencyObject d, double radiusWidth, double radiusHeight, double strokeThickness)
+		private static double CalculateEqualRadius()
 		{
-			RingShape ringShape = (RingShape)d;
-
-			double adjWidth = radiusWidth;
-			double adjHeight = radiusHeight;
-
-			var smaller = Math.Min(adjWidth, adjHeight);
-
-			if (smaller <= strokeThickness)
-				return strokeThickness;
-			else if (smaller >= ((_equalSize.Width / 2) - (strokeThickness / 2)))
-				return (_equalSize.Width / 2.0) - (strokeThickness / 2.0);
+			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;
 		}
@@ -315,15 +288,15 @@ private static Point CalculateCenter(double Width, double Height)
 			return calculatedCenter;
 		}
 
-		private static void CalculateAndSetNormalizedAngles(DependencyObject d, double minAngle, double maxAngle)
+		private static void CalculateAndSetNormalizedAngles()
 		{
-			var result = CalculateModulus(minAngle, 360);
+			var result = CalculateModulus(MinAngle, 360);
 			if (result >= 180)
 				result = result - 360;
 
 			_normalizedMinAngle = result;
 
-			result = CalculateModulus(maxAngle, 360);
+			result = CalculateModulus(MaxAngle, 360);
 
 			if (result < 180)
 				result = result + 360;
@@ -344,55 +317,39 @@ private static double CalculateModulus(double number, double divider)
 			return result;
 		}
 
-		private void ValidateAngle(DependencyObject d, double angle, bool isStart)
+		private double ValidateAngle(double angle)
 		{
-			if (angle >= _normalizedMaxAngle)
-			{
-				if (isStart)
-					_validStartAngle = _normalizedMaxAngle;
-				else
-					_validEndAngle = _normalizedMaxAngle;
-			}
-			else if (angle <= _normalizedMinAngle)
-			{
-				if (isStart)
-					_validStartAngle = _normalizedMinAngle;
-				else
-					_validEndAngle = _normalizedMinAngle;
-			}
-			else
-			{
-				if (isStart)
-					_validStartAngle = angle;
-				else
-					_validEndAngle = angle;
-			}
+			return angle >= _normalizedMaxAngle
+				? _normalizedMaxAngle
+				: angle <= _normalizedMinAngle
+					? _normalizedMinAngle
+					: angle;
 		}
 
-		private void AdjustRadiusWidth(DependencyObject d, double radiusWidth, double strokeThickness)
+		private void AdjustRadiusWidth()
 		{
-			var maxValue = (ringShape.Width / 2) - (ringShape.StrokeThickness / 2);
-			var threshold = strokeThickness;
+			var maxValue = (Width / 2) - (StrokeThickness / 2);
+			var threshold = StrokeThickness;
 
-			if (radiusWidth >= maxValue)
-				_radiusWidth = maxValue;
-			else if (radiusWidth <= maxValue && radiusWidth >= threshold)
-				_radiusWidth = radiusWidth;
+			if (RadiusWidth >= maxValue)
+				RadiusWidth = maxValue;
+			else if (RadiusWidth <= maxValue && RadiusWidth >= threshold)
+				RadiusWidth = RadiusWidth;
 			else
-				_radiusWidth = threshold;
+				RadiusWidth = threshold;
 		}
 
-		private void AdjustRadiusHeight(DependencyObject d, double radiusHeight, double strokeThickness)
+		private void AdjustRadiusHeight()
 		{
 			var maxValue = (Height / 2) - (StrokeThickness / 2);
-			var threshold = strokeThickness;
+			var threshold = StrokeThickness;
 
-			if (radiusHeight >= maxValue)
-				_radiusHeight = maxValue;
-			else if (radiusHeight <= maxValue && radiusHeight >= threshold)
-				_radiusHeight = radiusHeight;
+			if (RadiusHeight >= maxValue)
+				RadiusHeight = maxValue;
+			else if (RadiusHeight <= maxValue && RadiusHeight >= threshold)
+				RadiusHeight = RadiusHeight;
 			else
-				_radiusHeight = threshold;
+				RadiusHeight = threshold;
 		}
 
 		#endregion