Tidyup and fix warnings

Author: tznind

Terminal.Gui/Application/Application.Driver.cs

@@ -27,5 +27,9 @@ public static partial class Application // Driver abstractions
     [SerializableConfigurationProperty (Scope = typeof (SettingsScope))]
     public static string ForceDriver { get; set; } = string.Empty;
 
+
+    /// <summary>
+    /// Encoded sixel graphics to render on each loop of the application render loop.
+    /// </summary>
     public static List<SixelToRender> Sixel = new List<SixelToRender> ();
 }

Terminal.Gui/ConsoleDrivers/NetDriver.cs

@@ -1338,7 +1338,6 @@ private bool SetCursorPosition (int col, int row)
     }
 
     private CursorVisibility? _cachedCursorVisibility;
-    private static bool _supportsSixel;
 
     public override void UpdateCursor ()
     {

Terminal.Gui/Drawing/Quant/ColorQuantizer.cs

@@ -32,6 +32,11 @@ public class ColorQuantizer
 
     private readonly ConcurrentDictionary<Color, int> _nearestColorCache = new ();
 
+    /// <summary>
+    /// Populates <see cref="Palette"/> based on the <see cref="PaletteBuildingAlgorithm"/> and supplied
+    /// bitmap image.
+    /// </summary>
+    /// <param name="pixels"></param>
     public void BuildPalette (Color [,] pixels)
     {
         List<Color> allColors = new List<Color> ();
@@ -50,6 +55,12 @@ public void BuildPalette (Color [,] pixels)
         Palette = PaletteBuildingAlgorithm.BuildPalette (allColors, MaxColors);
     }
 
+    /// <summary>
+    /// Returns the index of the color in <see cref="Palette"/> that most closely
+    /// matches <paramref name="toTranslate"/> based on the current <see cref="DistanceAlgorithm"/>.
+    /// </summary>
+    /// <param name="toTranslate"></param>
+    /// <returns></returns>
     public int GetNearestColor (Color toTranslate)
     {
         if (_nearestColorCache.TryGetValue (toTranslate, out var cachedAnswer))

Terminal.Gui/Drawing/Quant/PopularityPaletteWithThreshold.cs

@@ -12,12 +12,19 @@ public class PopularityPaletteWithThreshold : IPaletteBuilder
     private readonly IColorDistance _colorDistance;
     private readonly double _mergeThreshold;
 
+    /// <summary>
+    /// Creates a new instance of the <see cref="PopularityPaletteWithThreshold"/> class using
+    /// the given threshold for merging similar colors.
+    /// </summary>
+    /// <param name="colorDistance"></param>
+    /// <param name="mergeThreshold"></param>
     public PopularityPaletteWithThreshold (IColorDistance colorDistance, double mergeThreshold)
     {
         _colorDistance = colorDistance;
         _mergeThreshold = mergeThreshold; // Set the threshold for merging similar colors
     }
 
+    /// <inheritdoc/>
     public List<Color> BuildPalette (List<Color> colors, int maxColors)
     {
         if (colors == null || colors.Count == 0 || maxColors <= 0)
@@ -62,6 +69,7 @@ public List<Color> BuildPalette (List<Color> colors, int maxColors)
     /// 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)
     {

Terminal.Gui/Drawing/SixelEncoder.cs

@@ -4,12 +4,10 @@
 // libsixel (C/C++) - https://github.com/saitoha/libsixel
 // Copyright (c) 2014-2016 Hayaki Saito @license MIT
 
-using Terminal.Gui;
-
 namespace Terminal.Gui;
 
 /// <summary>
-/// Encodes a images into the sixel console image output format.
+///     Encodes a images into the sixel console image output format.
 /// </summary>
 public class SixelEncoder
 {
@@ -35,32 +33,29 @@ e.g. to draw more color layers.
 
    */
 
-
     /// <summary>
-    /// Gets or sets the quantizer responsible for building a representative
-    /// limited color palette for images and for mapping novel colors in
-    /// images to their closest palette color
+    ///     Gets or sets the quantizer responsible for building a representative
+    ///     limited color palette for images and for mapping novel colors in
+    ///     images to their closest palette color
     /// </summary>
     public ColorQuantizer Quantizer { get; set; } = new ();
 
     /// <summary>
-    /// Encode the given bitmap into sixel encoding
+    ///     Encode the given bitmap into sixel encoding
     /// </summary>
     /// <param name="pixels"></param>
     /// <returns></returns>
     public string EncodeSixel (Color [,] pixels)
     {
-
         const string start = "\u001bP"; // Start sixel sequence
 
-
-            string defaultRatios = this.AnyHasAlphaOfZero(pixels) ? "0;1;0": "0;0;0"; // Defaults for aspect ratio and grid size
+        string defaultRatios = AnyHasAlphaOfZero (pixels) ? "0;1;0" : "0;0;0"; // Defaults for aspect ratio and grid size
         const string completeStartSequence = "q"; // Signals beginning of sixel image data
         const string noScaling = "\"1;1;"; // no scaling factors (1x1);
 
         string fillArea = GetFillArea (pixels);
 
-        string pallette = GetColorPalette (pixels );
+        string pallette = GetColorPalette (pixels);
 
         string pixelData = WriteSixel (pixels);
 
@@ -71,15 +66,14 @@ public string EncodeSixel (Color [,] pixels)
 
     private string WriteSixel (Color [,] pixels)
     {
-
-        StringBuilder sb = new StringBuilder ();
+        var sb = new StringBuilder ();
         int height = pixels.GetLength (1);
         int width = pixels.GetLength (0);
 
         // Iterate over each 'row' of the image. Because each sixel write operation
         // outputs a screen area 6 pixels high (and 1+ across) we must process the image
         // 6 'y' units at once (1 band)
-        for (int y = 0; y < height; y += 6)
+        for (var y = 0; y < height; y += 6)
         {
             sb.Append (ProcessBand (pixels, y, Math.Min (6, height - y), width));
 
@@ -107,69 +101,45 @@ private string ProcessBand (Color [,] pixels, int startY, int bandHeight, int wi
         Array.Fill (accu, (ushort)1);
         Array.Fill (slots, (short)-1);
 
-        var usedColorIdx = new List<int> ();
-        var targets = new List<List<string>> ();
+        List<int> usedColorIdx = new List<int> ();
+        List<List<string>> targets = new List<List<string>> ();
 
         // Process columns within the band
-        for (int x = 0; x < width; ++x)
+        for (var x = 0; x < width; ++x)
         {
             Array.Clear (code, 0, usedColorIdx.Count);
-            bool anyNonTransparentPixel = false;  // Track if any non-transparent pixels are found in this column
 
             // Process each row in the 6-pixel high band
-            for (int row = 0; row < bandHeight; ++row)
+            for (var row = 0; row < bandHeight; ++row)
             {
-                var color = pixels [x, startY + row];
+                Color color = pixels [x, startY + row];
 
                 int colorIndex = Quantizer.GetNearestColor (color);
 
                 if (color.A == 0) // Skip fully transparent pixels
                 {
                     continue;
                 }
-                else
-                {
-                    anyNonTransparentPixel = true;
-                }
 
                 if (slots [colorIndex] == -1)
                 {
-                    targets.Add (new List<string> ());
+                    targets.Add (new ());
+
                     if (x > 0)
                     {
                         last [usedColorIdx.Count] = 0;
                         accu [usedColorIdx.Count] = (ushort)x;
                     }
+
                     slots [colorIndex] = (short)usedColorIdx.Count;
                     usedColorIdx.Add (colorIndex);
                 }
 
                 code [slots [colorIndex]] |= (byte)(1 << row); // Accumulate SIXEL data
             }
 
-            /*
-            // If no non-transparent pixels are found in the entire column, it's fully transparent
-            if (!anyNonTransparentPixel)
-            {
-                // Emit fully transparent pixel data: #0!<width>?$
-                result.Append ($"#0!{width}?");
-
-                // Add the line terminator: use "$-" if it's not the last line, "$" if it's the last line
-                if (x < width - 1)
-                {
-                    result.Append ("$-");
-                }
-                else
-                {
-                    result.Append ("$");
-                }
-
-                // Skip to the next column as we have already handled transparency
-                continue;
-            }*/
-
             // Handle transitions between columns
-            for (int j = 0; j < usedColorIdx.Count; ++j)
+            for (var j = 0; j < usedColorIdx.Count; ++j)
             {
                 if (code [j] == last [j])
                 {
@@ -181,14 +151,15 @@ private string ProcessBand (Color [,] pixels, int startY, int bandHeight, int wi
                     {
                         targets [j].Add (CodeToSixel (last [j], accu [j]));
                     }
+
                     last [j] = (sbyte)code [j];
                     accu [j] = 1;
                 }
             }
         }
 
         // Process remaining data for this band
-        for (int j = 0; j < usedColorIdx.Count; ++j)
+        for (var j = 0; j < usedColorIdx.Count; ++j)
         {
             if (last [j] != 0)
             {
@@ -198,7 +169,8 @@ private string ProcessBand (Color [,] pixels, int startY, int bandHeight, int wi
 
         // Build the final output for this band
         var result = new StringBuilder ();
-        for (int j = 0; j < usedColorIdx.Count; ++j)
+
+        for (var j = 0; j < usedColorIdx.Count; ++j)
         {
             result.Append ($"#{usedColorIdx [j]}{string.Join ("", targets [j])}$");
         }
@@ -208,27 +180,42 @@ private string ProcessBand (Color [,] pixels, int startY, int bandHeight, int wi
 
     private static string CodeToSixel (int code, int repeat)
     {
-        char c = (char)(code + 63);
-        if (repeat > 3) return "!" + repeat + c;
-        if (repeat == 3) return c.ToString () + c + c;
-        if (repeat == 2) return c.ToString () + c;
+        var c = (char)(code + 63);
+
+        if (repeat > 3)
+        {
+            return "!" + repeat + c;
+        }
+
+        if (repeat == 3)
+        {
+            return c.ToString () + c + c;
+        }
+
+        if (repeat == 2)
+        {
+            return c.ToString () + c;
+        }
+
         return c.ToString ();
     }
 
     private string GetColorPalette (Color [,] pixels)
     {
         Quantizer.BuildPalette (pixels);
 
-        StringBuilder paletteSb = new StringBuilder ();
+        var paletteSb = new StringBuilder ();
 
-        for (int i = 0; i < Quantizer.Palette.Count; i++)
+        for (var i = 0; i < Quantizer.Palette.Count; i++)
         {
-            var color = Quantizer.Palette.ElementAt (i);
-            paletteSb.AppendFormat ("#{0};2;{1};{2};{3}",
-                i,
-                color.R * 100 / 255,
-                color.G * 100 / 255,
-                color.B * 100 / 255);
+            Color color = Quantizer.Palette.ElementAt (i);
+
+            paletteSb.AppendFormat (
+                                    "#{0};2;{1};{2};{3}",
+                                    i,
+                                    color.R * 100 / 255,
+                                    color.G * 100 / 255,
+                                    color.B * 100 / 255);
         }
 
         return paletteSb.ToString ();
@@ -241,15 +228,16 @@ private string GetFillArea (Color [,] pixels)
 
         return $"{widthInChars};{heightInChars}";
     }
+
     private bool AnyHasAlphaOfZero (Color [,] pixels)
     {
         int width = pixels.GetLength (0);
         int height = pixels.GetLength (1);
 
         // Loop through each pixel in the 2D array
-        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++)
             {
                 // Check if the alpha component (A) is 0
                 if (pixels [x, y].A == 0)
@@ -258,6 +246,7 @@ private bool AnyHasAlphaOfZero (Color [,] pixels)
                 }
             }
         }
+
         return false; // No pixel with A of 0 was found
     }
-}
+}