System.Drawing.Color (#141)

* Use System.Drawing.Color

* builds

* builds

* add TODO

* ColoredAtom -> Colored

* ColoredTextAtom -> Colored

* convert color to tex

* replace warnings with TODOs

* standardize html/hex colour format

* annotate

* debug code

* Revert "debug code"

This reverts commit 917a295.

* remove spurious usings

* fix Colored and ColorBox to latex

* parameter name lowercase

* American

* remove NoEnhancedColors

* Remove Ooui

* casing

* Fix 0x - but this should probably be removed

* Fix tests

* Remove 0x syntax

* Remove warnings that are TODOs

* reduce time taken by fsharp test

* Fix most tests

* fix mathpaintersettings tests

* Update CSharpMath.Rendering.Tests

* ColorExtensions should be part of LaTeXSettings

* Resolve some warnings

* ColoredAtom.cs -> Colored.cs

* Lowercase variable

* Be consistent with parameter name "colored"

* Consistent spacing

* remove unused `using`

Co-authored-by: Charles Roddie <[email protected]>
Co-authored-by: Hadrian Tang <[email protected]>
Co-authored-by: FoggyFinder <[email protected]>

Author: 3 people

CSharpMath.Apple/BackEnd/AppleGraphicsContext.cs

@@ -4,7 +4,6 @@
 using CoreGraphics;
 using CoreText;
 using CSharpMath.Display;
-using Color = CSharpMath.Structures.Color;
 using TFont = CSharpMath.Apple.AppleMathFont;
 using TGlyph = System.UInt16;
 

CSharpMath.Apple/Extensions/AttributedGlyphRun.cs

@@ -23,7 +23,7 @@ public static NSMutableAttributedString ToNsAttributedString
         if (kernedGlyphs[i].KernAfterGlyph is var kern && !(kern is 0))
           attributedString.AddAttribute
             (CTStringAttributeKey.KerningAdjustment, new NSNumber(kern), range);
-        if (kernedGlyphs[i].Foreground is Structures.Color foreground)
+        if (kernedGlyphs[i].Foreground is System.Drawing.Color foreground)
           attributedString.AddAttribute(CTStringAttributeKey.ForegroundColor,
             ObjCRuntime.Runtime.GetNSObject(foreground.ToCGColor().Handle), range);
       }

CSharpMath.Apple/Extensions/Color.cs

@@ -1,9 +1,9 @@
 namespace CSharpMath.Apple {
-  using Structures;
+  using System.Drawing;
   partial class Extensions {
     public static CoreGraphics.CGColor ToCGColor(this Color color) =>
-      new CoreGraphics.CGColor(color.Rf, color.Gf, color.Bf, color.Af);
+      new CoreGraphics.CGColor(color.R / 255f, color.G / 255f, color.B / 255f, color.A / 255f);
     public static UIKit.UIColor ToUIColor(this Color color) =>
-      new UIKit.UIColor(color.Rf, color.Gf, color.Bf, color.Af);
+      new UIKit.UIColor(color.R / 255f, color.G / 255f, color.B / 255f, color.A / 255f);
   }
 }

CSharpMath.Avalonia/AvaloniaCanvas.cs

@@ -4,7 +4,7 @@
 using Avalonia.Media;
 
 using CSharpMath.Rendering.FrontEnd;
-using CSharpMathColor = CSharpMath.Structures.Color;
+using CSharpMathColor = System.Drawing.Color;
 
 namespace CSharpMath.Avalonia {
   public sealed class AvaloniaCanvas : ICanvas {

CSharpMath.Avalonia/AvaloniaPath.cs

@@ -1,5 +1,5 @@
 using CSharpMath.Rendering.FrontEnd;
-using CSharpMathColor = CSharpMath.Structures.Color;
+using CSharpMathColor = System.Drawing.Color;
 
 using Avalonia;
 using Avalonia.Media;

CSharpMath.Avalonia/Extensions.cs

@@ -1,22 +1,19 @@
-using SizeF = System.Drawing.SizeF;
-
 using Avalonia;
 using Avalonia.Media;
 using Avalonia.Media.Imaging;
 using AvaloniaColor = Avalonia.Media.Color;
 using AvaloniaTextAlignment = Avalonia.Media.TextAlignment;
 
 using CSharpMath.Rendering.FrontEnd;
-using CSharpMathColor = CSharpMath.Structures.Color;
 using CSharpMathTextAlignment = CSharpMath.Rendering.FrontEnd.TextAlignment;
 
 namespace CSharpMath.Avalonia {
   public static class Extensions {
-    public static AvaloniaColor ToAvaloniaColor(this CSharpMathColor color) =>
+    public static AvaloniaColor ToAvaloniaColor(this System.Drawing.Color color) =>
         new AvaloniaColor(color.A, color.R, color.G, color.B);
 
-    internal static CSharpMathColor ToCSharpMathColor(this AvaloniaColor color) =>
-        new CSharpMathColor(color.R, color.G, color.B, color.A);
+    internal static System.Drawing.Color ToCSharpMathColor(this AvaloniaColor color) =>
+        System.Drawing.Color.FromArgb(color.A, color.R, color.G, color.B);
 
     internal static CSharpMathTextAlignment ToCSharpMathTextAlignment(this AvaloniaTextAlignment alignment) =>
       alignment switch
@@ -27,7 +24,7 @@ internal static CSharpMathTextAlignment ToCSharpMathTextAlignment(this AvaloniaT
         _ => CSharpMathTextAlignment.Left
       };
 
-    public static SolidColorBrush ToSolidColorBrush(this CSharpMathColor color) =>
+    public static SolidColorBrush ToSolidColorBrush(this System.Drawing.Color color) =>
         new SolidColorBrush(color.ToAvaloniaColor());
 
     class DrawVisual<TContent> : Visual where TContent : class {

CSharpMath.Avalonia/MathPainter.cs

@@ -1,7 +1,7 @@
 using AvaloniaColor = Avalonia.Media.Color;
 
 using CSharpMath.Rendering.FrontEnd;
-using CSharpMathColor = CSharpMath.Structures.Color;
+using CSharpMathColor = System.Drawing.Color;
 
 namespace CSharpMath.Avalonia {
   public sealed class MathPainter : MathPainter<AvaloniaCanvas, AvaloniaColor> {

CSharpMath.Avalonia/TextPainter.cs

@@ -1,7 +1,7 @@
 using AvaloniaColor = Avalonia.Media.Color;
 
 using CSharpMath.Rendering.FrontEnd;
-using CSharpMathColor = CSharpMath.Structures.Color;
+using CSharpMathColor = System.Drawing.Color;
 
 namespace CSharpMath.Avalonia {
   public sealed class TextPainter : TextPainter<AvaloniaCanvas, AvaloniaColor> {

CSharpMath.CoreTests/LaTeXParserTest.cs

@@ -456,9 +456,9 @@ public void TestMatrix(string env, string left, string right, string leftOutput,
     [InlineData(@"\color{red}{{\left( \begin{matrix}1&2\\ 3&4\end{matrix}\right) }}")]
     public void TestRedMatrix(string input) {
       var list = ParseLaTeX(input);
-      Assert.Collection(list, CheckAtom<Color>("", color => {
-        Assert.Equal(new Structures.Color(255, 0, 0), color.Colour);
-        Assert.Collection(color.InnerList,
+      Assert.Collection(list, CheckAtom<Colored>("", colored => {
+        Assert.Equal(System.Drawing.Color.FromArgb(255, 0, 0), colored.Color);
+        Assert.Collection(colored.InnerList,
           CheckAtom<Inner>("", inner => {
             Assert.Equal(new Boundary("("), inner.LeftBoundary);
             Assert.Equal(new Boundary(")"), inner.RightBoundary);
@@ -1091,43 +1091,43 @@ public void TestNoLimits(string input, string output, bool? limits) {
 
     // Sync with CSharpMath.Rendering.Text.Tests TextLaTeXParserTests
     [Theory]
-    [InlineData("0xFFF", "white", 0xFF, 0xFF, 0xFF)]
-    [InlineData("#ff0", "yellow", 0xFF, 0xFF, 0x00)]
-    [InlineData("0xf00f", "blue", 0x00, 0x00, 0xFF)]
-    [InlineData("#F0F0", "lime", 0x00, 0xFF, 0x00)]
-    [InlineData("0x008000", "green", 0x00, 0x80, 0x00)]
+    [InlineData("#FFFFFF", "white", 0xFF, 0xFF, 0xFF)]
+    [InlineData("#ffff00", "yellow", 0xFF, 0xFF, 0x00)]
+    [InlineData("#ff0000ff", "blue", 0x00, 0x00, 0xFF)]
+    [InlineData("#FF00FF00", "lime", 0x00, 0xFF, 0x00)]
+    [InlineData("#008000", "green", 0x00, 0x80, 0x00)]
     [InlineData("#d3D3d3", "lightgray", 0xD3, 0xD3, 0xD3)]
-    [InlineData("0xFf000000", "black", 0x00, 0x00, 0x00)]
+    [InlineData("#Ff000000", "black", 0x00, 0x00, 0x00)]
     [InlineData("#fFa9A9a9", "gray", 0xA9, 0xA9, 0xA9)]
     [InlineData("cyan", "cyan", 0x00, 0xFF, 0xFF)]
     [InlineData("BROWN", "brown", 0x96, 0x4B, 0x00)]
     [InlineData("oLIve", "olive", 0x80, 0x80, 0x00)]
-    [InlineData("0x12345678", "#12345678", 0x34, 0x56, 0x78, 0x12)]
+    [InlineData("#12345678", "#12345678", 0x34, 0x56, 0x78, 0x12)]
     [InlineData("#fedcba98", "#FEDCBA98", 0xDC, 0xBA, 0x98, 0xFE)]
     public void TestColor(string inColor, string outColor, byte r, byte g, byte b, byte a = 0xFF) {
       var list = ParseLaTeX($@"\color{{{inColor}}}ab");
       Assert.Collection(list,
-        CheckAtom<Color>("", color => {
-          Assert.Equal(r, color.Colour.R);
-          Assert.Equal(g, color.Colour.G);
-          Assert.Equal(b, color.Colour.B);
-          Assert.Equal(a, color.Colour.A);
-          Assert.False(color.ScriptsAllowed);
-          Assert.Collection(color.InnerList, CheckAtom<Variable>("a"));
+        CheckAtom<Colored>("", colored => {
+          Assert.Equal(r, colored.Color.R);
+          Assert.Equal(g, colored.Color.G);
+          Assert.Equal(b, colored.Color.B);
+          Assert.Equal(a, colored.Color.A);
+          Assert.False(colored.ScriptsAllowed);
+          Assert.Collection(colored.InnerList, CheckAtom<Variable>("a"));
         }),
         CheckAtom<Variable>("b")
       );
       Assert.Equal($@"\color{{{outColor}}}{{a}}b", LaTeXParser.MathListToLaTeX(list).ToString());
 
       list = ParseLaTeX($@"\colorbox{{{inColor}}}ab");
       Assert.Collection(list,
-        CheckAtom<ColorBox>("", color => {
-          Assert.Equal(r, color.Colour.R);
-          Assert.Equal(g, color.Colour.G);
-          Assert.Equal(b, color.Colour.B);
-          Assert.Equal(a, color.Colour.A);
-          Assert.False(color.ScriptsAllowed);
-          Assert.Collection(color.InnerList, CheckAtom<Variable>("a"));
+        CheckAtom<ColorBox>("", colorBox => {
+          Assert.Equal(r, colorBox.Color.R);
+          Assert.Equal(g, colorBox.Color.G);
+          Assert.Equal(b, colorBox.Color.B);
+          Assert.Equal(a, colorBox.Color.A);
+          Assert.False(colorBox.ScriptsAllowed);
+          Assert.Collection(colorBox.InnerList, CheckAtom<Variable>("a"));
         }),
         CheckAtom<Variable>("b")
       );
@@ -1138,18 +1138,18 @@ public void TestColor(string inColor, string outColor, byte r, byte g, byte b, b
     public void TestColorScripts() {
       var list = ParseLaTeX(@"\color{red}1\colorbox{blue}2");
       Assert.Collection(list,
-        CheckAtom<Color>("", color => {
-          Assert.Equal("red", color.Colour.ToString());
-          Assert.Empty(color.Superscript);
-          Assert.Throws<InvalidOperationException>(() => color.Superscript.Add(new Variable("a")));
-          Assert.Throws<InvalidOperationException>(() => color.Superscript.Append(new MathList(new Variable("a"))));
-          Assert.Empty(color.Subscript);
-          Assert.Throws<InvalidOperationException>(() => color.Subscript.Add(new Variable("b")));
-          Assert.Throws<InvalidOperationException>(() => color.Subscript.Append(new MathList(new Variable("b"))));
-          Assert.Collection(color.InnerList, CheckAtom<Number>("1"));
+        CheckAtom<Colored>("", colored => {
+          Assert.Equal("red", LaTeXSettings.ColorToString(colored.Color, new StringBuilder()).ToString());
+          Assert.Empty(colored.Superscript);
+          Assert.Throws<InvalidOperationException>(() => colored.Superscript.Add(new Variable("a")));
+          Assert.Throws<InvalidOperationException>(() => colored.Superscript.Append(new MathList(new Variable("a"))));
+          Assert.Empty(colored.Subscript);
+          Assert.Throws<InvalidOperationException>(() => colored.Subscript.Add(new Variable("b")));
+          Assert.Throws<InvalidOperationException>(() => colored.Subscript.Append(new MathList(new Variable("b"))));
+          Assert.Collection(colored.InnerList, CheckAtom<Number>("1"));
         }),
         CheckAtom<ColorBox>("", colorBox => {
-          Assert.Equal("blue", colorBox.Colour.ToString());
+          Assert.Equal("blue", LaTeXSettings.ColorToString(colorBox.Color, new StringBuilder()).ToString());
           Assert.Empty(colorBox.Superscript);
           Assert.Throws<InvalidOperationException>(() => colorBox.Superscript.Add(new Variable("a")));
           Assert.Throws<InvalidOperationException>(() => colorBox.Superscript.Append(new MathList(new Variable("a"))));

CSharpMath.CoreTests/MathAtomTest.cs

@@ -184,16 +184,16 @@ public void TestCopyOpen() {
       CheckClone(open.Subscript, clone.Subscript);
     }
     [Fact]
-    public void TestCopyColor() {
-      var color = new Color(new Structures.Color(255, 0, 0), new MathList(new Open("(")));
-      var clone = color.Clone(false);
-      Assert.Equal(new Structures.Color(255, 0, 0), clone.Colour);
-      CheckClone(color, clone);
-      CheckClone(color.InnerList, clone.InnerList);
+    public void TestCopyColored() {
+      var colored = new Colored(System.Drawing.Color.FromArgb(255, 0, 0), new MathList(new Open("(")));
+      var clone = colored.Clone(false);
+      Assert.Equal(System.Drawing.Color.FromArgb(255, 0, 0), clone.Color);
+      CheckClone(colored, clone);
+      CheckClone(colored.InnerList, clone.InnerList);
 
-      var colorBox = new ColorBox(new Structures.Color(128, 0, 0), new MathList(new Close(")")));
+      var colorBox = new ColorBox(System.Drawing.Color.FromArgb(128, 0, 0), new MathList(new Close(")")));
       var cloneBox = colorBox.Clone(false);
-      Assert.Equal(new Structures.Color(128, 0, 0), cloneBox.Colour);
+      Assert.Equal(System.Drawing.Color.FromArgb(128, 0, 0), cloneBox.Color);
       CheckClone(colorBox, cloneBox);
       CheckClone(colorBox.InnerList, cloneBox.InnerList);
     }