Run TidyCode on all new classes

Author: tznind

Terminal.Gui/Drawing/AssumeSupportDetector.cs

@@ -1,19 +1,19 @@
 namespace Terminal.Gui;
 
 /// <summary>
-/// Implementation of <see cref="ISixelSupportDetector"/> that assumes best
-/// case scenario (full support including transparency with 10x20 resolution).
+///     Implementation of <see cref="ISixelSupportDetector"/> that assumes best
+///     case scenario (full support including transparency with 10x20 resolution).
 /// </summary>
 public class AssumeSupportDetector : ISixelSupportDetector
 {
-    /// <inheritdoc />
+    /// <inheritdoc/>
     public SixelSupportResult Detect ()
     {
-        return new SixelSupportResult
+        return new()
         {
             IsSupported = true,
             MaxPaletteColors = 256,
-            Resolution = new Size (10, 20),
+            Resolution = new (10, 20),
             SupportsTransparency = true
         };
     }

Terminal.Gui/Drawing/ISixelSupportDetector.cs

@@ -1,14 +1,14 @@
 namespace Terminal.Gui;
 
 /// <summary>
-/// Interface for detecting sixel support. Either through
-/// ansi requests to terminal or config file etc.
+///     Interface for detecting sixel support. Either through
+///     ansi requests to terminal or config file etc.
 /// </summary>
 public interface ISixelSupportDetector
 {
     /// <summary>
-    /// Gets the supported sixel state e.g. by sending Ansi escape sequences
-    /// or from a config file etc.
+    ///     Gets the supported sixel state e.g. by sending Ansi escape sequences
+    ///     or from a config file etc.
     /// </summary>
     /// <returns>Description of sixel support.</returns>
     public SixelSupportResult Detect ();

Terminal.Gui/Drawing/Quant/ColorQuantizer.cs

@@ -3,49 +3,49 @@
 namespace Terminal.Gui;
 
 /// <summary>
-/// Translates colors in an image into a Palette of up to <see cref="MaxColors"/> colors (typically 256).
+///     Translates colors in an image into a Palette of up to <see cref="MaxColors"/> colors (typically 256).
 /// </summary>
 public class ColorQuantizer
 {
     /// <summary>
-    /// Gets the current colors in the palette based on the last call to
-    /// <see cref="BuildPalette"/>.
+    ///     Gets the current colors in the palette based on the last call to
+    ///     <see cref="BuildPalette"/>.
     /// </summary>
     public IReadOnlyCollection<Color> Palette { get; private set; } = new List<Color> ();
 
     /// <summary>
-    /// Gets or sets the maximum number of colors to put into the <see cref="Palette"/>.
-    /// Defaults to 256 (the maximum for sixel images).
+    ///     Gets or sets the maximum number of colors to put into the <see cref="Palette"/>.
+    ///     Defaults to 256 (the maximum for sixel images).
     /// </summary>
     public int MaxColors { get; set; } = 256;
 
     /// <summary>
-    /// Gets or sets the algorithm used to map novel colors into existing
-    /// palette colors (closest match). Defaults to <see cref="EuclideanColorDistance"/>
+    ///     Gets or sets the algorithm used to map novel colors into existing
+    ///     palette colors (closest match). Defaults to <see cref="EuclideanColorDistance"/>
     /// </summary>
     public IColorDistance DistanceAlgorithm { get; set; } = new EuclideanColorDistance ();
 
     /// <summary>
-    /// Gets or sets the algorithm used to build the <see cref="Palette"/>.
+    ///     Gets or sets the algorithm used to build the <see cref="Palette"/>.
     /// </summary>
-    public IPaletteBuilder PaletteBuildingAlgorithm { get; set; } = new PopularityPaletteWithThreshold (new EuclideanColorDistance (),8) ;
+    public IPaletteBuilder PaletteBuildingAlgorithm { get; set; } = new PopularityPaletteWithThreshold (new EuclideanColorDistance (), 8);
 
     private readonly ConcurrentDictionary<Color, int> _nearestColorCache = new ();
 
     /// <summary>
-    /// Builds a <see cref="Palette"/> of colors that most represent the colors used in <paramref name="pixels"/> image.
-    /// This is based on the currently configured <see cref="PaletteBuildingAlgorithm"/>.
+    ///     Builds a <see cref="Palette"/> of colors that most represent the colors used in <paramref name="pixels"/> image.
+    ///     This is based on the currently configured <see cref="PaletteBuildingAlgorithm"/>.
     /// </summary>
     /// <param name="pixels"></param>
     public void BuildPalette (Color [,] pixels)
     {
-        List<Color> allColors = new List<Color> ();
+        List<Color> allColors = new ();
         int width = pixels.GetLength (0);
         int height = pixels.GetLength (1);
 
-        for (int x = 0; x < width; x++)
+        for (var x = 0; x < width; x++)
         {
-            for (int y = 0; y < height; y++)
+            for (var y = 0; y < height; y++)
             {
                 allColors.Add (pixels [x, y]);
             }
@@ -57,14 +57,14 @@ public void BuildPalette (Color [,] pixels)
 
     public int GetNearestColor (Color toTranslate)
     {
-        if (_nearestColorCache.TryGetValue (toTranslate, out var cachedAnswer))
+        if (_nearestColorCache.TryGetValue (toTranslate, out int cachedAnswer))
         {
             return cachedAnswer;
         }
 
         // Simple nearest color matching based on DistanceAlgorithm
-        double minDistance = double.MaxValue;
-        int nearestIndex = 0;
+        var minDistance = double.MaxValue;
+        var nearestIndex = 0;
 
         for (var index = 0; index < Palette.Count; index++)
         {
@@ -79,6 +79,7 @@ public int GetNearestColor (Color toTranslate)
         }
 
         _nearestColorCache.TryAdd (toTranslate, nearestIndex);
+
         return nearestIndex;
     }
-}
+}

Terminal.Gui/Drawing/Quant/EuclideanColorDistance.cs

@@ -1,20 +1,21 @@
 namespace Terminal.Gui;
 
 /// <summary>
-/// <para>
-/// Calculates the distance between two colors using Euclidean distance in 3D RGB space.
-/// This measures the straight-line distance between the two points representing the colors.
-///</para>
-/// <para>
-/// Euclidean distance in RGB space is calculated as:
-/// </para>
-/// <code>
-///     √((R2 - R1)² + (G2 - G1)² + (B2 - B1)²)
-/// </code>
-/// <remarks>Values vary from 0 to ~441.67 linearly</remarks>
-/// 
-/// <remarks>This distance metric is commonly used for comparing colors in RGB space, though
-/// it doesn't account for perceptual differences in color.</remarks>
+///     <para>
+///         Calculates the distance between two colors using Euclidean distance in 3D RGB space.
+///         This measures the straight-line distance between the two points representing the colors.
+///     </para>
+///     <para>
+///         Euclidean distance in RGB space is calculated as:
+///     </para>
+///     <code>
+///      √((R2 - R1)² + (G2 - G1)² + (B2 - B1)²)
+///  </code>
+///     <remarks>Values vary from 0 to ~441.67 linearly</remarks>
+///     <remarks>
+///         This distance metric is commonly used for comparing colors in RGB space, though
+///         it doesn't account for perceptual differences in color.
+///     </remarks>
 /// </summary>
 public class EuclideanColorDistance : IColorDistance
 {
@@ -24,6 +25,7 @@ public double CalculateDistance (Color c1, Color c2)
         int rDiff = c1.R - c2.R;
         int gDiff = c1.G - c2.G;
         int bDiff = c1.B - c2.B;
+
         return Math.Sqrt (rDiff * rDiff + gDiff * gDiff + bDiff * bDiff);
     }
 }

Terminal.Gui/Drawing/Quant/IColorDistance.cs

@@ -1,15 +1,15 @@
 namespace Terminal.Gui;
 
 /// <summary>
-/// Interface for algorithms that compute the relative distance between pairs of colors.
-/// This is used for color matching to a limited palette, such as in Sixel rendering.
+///     Interface for algorithms that compute the relative distance between pairs of colors.
+///     This is used for color matching to a limited palette, such as in Sixel rendering.
 /// </summary>
 public interface IColorDistance
 {
     /// <summary>
-    /// Computes a similarity metric between two <see cref="Color"/> instances.
-    /// A larger value indicates more dissimilar colors, while a smaller value indicates more similar colors.
-    /// The metric is internally consistent for the given algorithm.
+    ///     Computes a similarity metric between two <see cref="Color"/> instances.
+    ///     A larger value indicates more dissimilar colors, while a smaller value indicates more similar colors.
+    ///     The metric is internally consistent for the given algorithm.
     /// </summary>
     /// <param name="c1">The first color.</param>
     /// <param name="c2">The second color.</param>

Terminal.Gui/Drawing/Quant/IPaletteBuilder.cs

@@ -1,16 +1,18 @@
 namespace Terminal.Gui;
 
 /// <summary>
-/// Builds a palette of a given size for a given set of input colors.
+///     Builds a palette of a given size for a given set of input colors.
 /// </summary>
 public interface IPaletteBuilder
 {
     /// <summary>
-    /// Reduce the number of <paramref name="colors"/> to <paramref name="maxColors"/> (or less)
-    /// using an appropriate selection algorithm.
+    ///     Reduce the number of <paramref name="colors"/> to <paramref name="maxColors"/> (or less)
+    ///     using an appropriate selection algorithm.
     /// </summary>
-    /// <param name="colors">Color of every pixel in the image. Contains duplication in order
-    /// to support algorithms that weigh how common a color is.</param>
+    /// <param name="colors">
+    ///     Color of every pixel in the image. Contains duplication in order
+    ///     to support algorithms that weigh how common a color is.
+    /// </param>
     /// <param name="maxColors">The maximum number of colours that should be represented.</param>
     /// <returns></returns>
     List<Color> BuildPalette (List<Color> colors, int maxColors);

Terminal.Gui/Drawing/Quant/PopularityPaletteWithThreshold.cs

@@ -2,18 +2,18 @@
 using Color = Terminal.Gui.Color;
 
 /// <summary>
-/// Simple fast palette building algorithm which uses the frequency that a color is seen
-/// to determine whether it will appear in the final palette. Includes a threshold where
-/// by colors will be considered 'the same'. This reduces the chance of under represented
-/// colors being missed completely.
+///     Simple fast palette building algorithm which uses the frequency that a color is seen
+///     to determine whether it will appear in the final palette. Includes a threshold where
+///     by colors will be considered 'the same'. This reduces the chance of under represented
+///     colors being missed completely.
 /// </summary>
 public class PopularityPaletteWithThreshold : IPaletteBuilder
 {
     private readonly IColorDistance _colorDistance;
     private readonly double _mergeThreshold;
 
     /// <summary>
-    /// Creates a new instance with the given color grouping parameters.
+    ///     Creates a new instance with the given color grouping parameters.
     /// </summary>
     /// <param name="colorDistance">Determines which different colors can be considered the same.</param>
     /// <param name="mergeThreshold">Threshold for merging two colors together.</param>
@@ -31,7 +31,7 @@ public List<Color> BuildPalette (List<Color> colors, int maxColors)
         }
 
         // Step 1: Build the histogram of colors (count occurrences)
-        Dictionary<Color, int> colorHistogram = new Dictionary<Color, int> ();
+        Dictionary<Color, int> colorHistogram = new ();
 
         foreach (Color color in colors)
         {
@@ -64,14 +64,14 @@ public List<Color> BuildPalette (List<Color> colors, int maxColors)
     }
 
     /// <summary>
-    /// Merge colors in the histogram if they are within the threshold distance
+    ///     Merge colors in the histogram if they are within the threshold distance
     /// </summary>
     /// <param name="colorHistogram"></param>
     /// <param name="maxColors"></param>
     /// <returns></returns>
     private Dictionary<Color, int> MergeSimilarColors (Dictionary<Color, int> colorHistogram, int maxColors)
     {
-        Dictionary<Color, int> mergedHistogram = new Dictionary<Color, int> ();
+        Dictionary<Color, int> mergedHistogram = new ();
 
         foreach (KeyValuePair<Color, int> entry in colorHistogram)
         {