Completely obliterated MathAtomType from existence

Author: Happypig375

CSharpMath.Apple/AppleMathView.cs

@@ -1,7 +1,6 @@
+using CSharpMath.Atoms;
 using CSharpMath.Display;
-using CSharpMath.Enumerations;
 using CSharpMath.FrontEnd;
-using CSharpMath.Atoms;
 using CoreGraphics;
 using UIKit;
 using TGlyph = System.UInt16;

CSharpMath.Apple/Typesetting/JsonMathTable.cs

@@ -133,10 +133,11 @@ public override float RadicalExtraAscender(TFont font) =>
     private const string _startConnectorKey = "startConnector";
     private const string _extenderKey = "extender";
     private const string _glyphKey = "glyph";
-    public override IEnumerable<GlyphPart<TGlyph>> GetVerticalGlyphAssembly(TGlyph rawGlyph, TFont font) =>
+    public override IEnumerable<Display.Text.GlyphPart<TGlyph>> GetVerticalGlyphAssembly
+      (TGlyph rawGlyph, TFont font) =>
       _assemblyTable[GlyphNameProvider.GetGlyphName(rawGlyph)]?[_assemblyPartsKey] is JArray parts
       ? parts.Select(partInfo =>
-        new GlyphPart<TGlyph>(
+        new Display.Text.GlyphPart<TGlyph>(
           GlyphNameProvider.GetGlyph(partInfo[_glyphKey].Value<string>()),
           FontUnitsToPt(font, partInfo[_advanceKey].Value<int>()),
           FontUnitsToPt(font, partInfo[_startConnectorKey].Value<int>()),

CSharpMath.Editor.Tests/IndexForPointTests.cs

@@ -1,6 +1,5 @@
 using System.Drawing;
 using CSharpMath.Atoms;
-using CSharpMath.Enumerations;
 using CSharpMath.Tests.FrontEnd;
 using Xunit;
 

CSharpMath.Editor/Extensions/IDisplay.cs

@@ -1,17 +1,18 @@
-using System;
-using System.Collections.Generic;
 using System.Drawing;
-using System.Text;
 
 namespace CSharpMath.Editor {
-  using Range = Atoms.Range;
   using Display;
+  using Display.Text;
 
   public static partial class DisplayEditingExtensions {
-    ///<summary>Number of pixels outside the bound to allow a point to be considered as part of the bounds.</summary>
+    /// <summary>
+    /// Number of pixels outside the bound to allow a point to be considered as part of the bounds.
+    /// </summary>
     public const float PixelDelta = 2;
 
-    ///<summary>Calculates the manhattan distance from a point to the nearest boundary of the rectangle.</summary>
+    /// <summary>
+    /// Calculates the manhattan distance from a point to the nearest boundary of the rectangle.
+    /// </summary>
     public static float DistanceFromPointToRect(PointF point, RectangleF rect) {
       float distance = 0;
       if (point.X < rect.X)
@@ -27,9 +28,9 @@ public static float DistanceFromPointToRect(PointF point, RectangleF rect) {
     }
 
     /// <summary>
-    /// Finds the index in the mathlist before which a new character should be inserted.Returns null if it cannot find the index.
+    /// Finds the index in the mathlist before which a new character should be inserted.
+    /// Returns null if it cannot find the index.
     /// </summary>
-    /// <returns>Null if it cannot find the index.</returns>
     public static MathListIndex? IndexForPoint<TFont, TGlyph>(
       this IDisplay<TFont, TGlyph> display,
       FrontEnd.TypesettingContext<TFont, TGlyph> context, PointF point)
@@ -52,7 +53,9 @@ public static float DistanceFromPointToRect(PointF point, RectangleF rect) {
       ListDisplay<TFont, TGlyph> list => list.PointForIndex(context, index),
       _ => null,
     };
-    public static void HighlightCharacterAt<TFont, TGlyph>(this IDisplay<TFont, TGlyph> display, MathListIndex index, Structures.Color color) where TFont : IFont<TGlyph> {
+    public static void HighlightCharacterAt<TFont, TGlyph>
+      (this IDisplay<TFont, TGlyph> display, MathListIndex index, Structures.Color color)
+      where TFont : IFont<TGlyph> {
       switch (display) {
         case TextLineDisplay<TFont, TGlyph> text:
           text.HighlightCharacterAt(index, color);
@@ -70,7 +73,8 @@ public static void HighlightCharacterAt<TFont, TGlyph>(this IDisplay<TFont, TGly
           break;
       }
     }
-    public static void Highlight<TFont, TGlyph>(this IDisplay<TFont, TGlyph> display, Structures.Color color) where TFont : IFont<TGlyph> {
+    public static void Highlight<TFont, TGlyph>(this IDisplay<TFont, TGlyph> display, Structures.Color color)
+      where TFont : IFont<TGlyph> {
       switch (display) {
         case TextLineDisplay<TFont, TGlyph> text:
           text.Highlight(color);

CSharpMath.Editor/Extensions/ListDisplay.cs

@@ -38,8 +38,7 @@ partial class DisplayEditingExtensions {
                    : MathListIndex.Level0Index(self.Range.Location);
           else if (translatedPoint.X >= self.Width + PixelDelta) {
             // if closest is a script
-            if (closest != null && closest is ListDisplay<TFont, TGlyph> ld
-                && ld.LinePosition != Enumerations.LinePosition.Regular) {
+            if (closest is ListDisplay<TFont, TGlyph> ld && ld.LinePosition != LinePosition.Regular) {
               // then we try to find its parent
               var parent = self.Displays.FirstOrDefault(d => d.HasScript && d.Range.Contains(ld.IndexInParent));
               if (parent != null) {
@@ -73,20 +72,27 @@ partial class DisplayEditingExtensions {
 
       var index = displayWithPoint.IndexForPoint(context, translatedPoint);
       if (displayWithPoint is ListDisplay<TFont, TGlyph> closestLine) {
-        if (closestLine.LinePosition is Enumerations.LinePosition.Regular)
-          throw new ArgumentException(
-            $"{nameof(ListDisplay<TFont, TGlyph>)} {nameof(ListDisplay<TFont, TGlyph>.LinePosition)} {nameof(Enumerations.LinePosition.Regular)} " +
+        if (closestLine.LinePosition is LinePosition.Regular)
+          throw new ArgumentException(nameof(ListDisplay<TFont, TGlyph>) + " " +
+            nameof(ListDisplay<TFont, TGlyph>.LinePosition) + " " + nameof(LinePosition.Regular) + " " +
             $"inside an {nameof(ListDisplay<TFont, TGlyph>)} - shouldn't happen", nameof(self));
         // This is a subscript or a superscript, return the right type of subindex
-        var indexType = closestLine.LinePosition is Enumerations.LinePosition.Subscript ? MathListSubIndexType.Subscript : MathListSubIndexType.Superscript;
+        var indexType =
+          closestLine.LinePosition is LinePosition.Subscript
+          ? MathListSubIndexType.Subscript
+          : MathListSubIndexType.Superscript;
         // The index of the atom this denotes.
         if (closestLine.IndexInParent is int.MinValue)
-          throw new ArgumentException($"Index was not set for a {indexType} in the {nameof(ListDisplay<TFont, TGlyph>)}.", nameof(self));
+          throw new ArgumentException
+            ($"Index was not set for a {indexType} in the {nameof(ListDisplay<TFont, TGlyph>)}.", nameof(self));
         return MathListIndex.IndexAtLocation(closestLine.IndexInParent, indexType, index);
       } else if (displayWithPoint.HasScript)
-        //The display list has a subscript or a superscript. If the index is at the end of the atom, then we need to put it before the sub/super script rather than after.
+        // The display list has a subscript or a superscript.
+        // If the index is at the end of the atom,
+        // then we need to put it before the sub/super script rather than after.
         if (index?.AtomIndex == displayWithPoint.Range.End)
-          return MathListIndex.IndexAtLocation(index.AtomIndex - 1, MathListSubIndexType.BetweenBaseAndScripts, MathListIndex.Level0Index(1));
+          return MathListIndex.IndexAtLocation
+            (index.AtomIndex - 1, MathListSubIndexType.BetweenBaseAndScripts, MathListIndex.Level0Index(1));
       return index;
     }
 
@@ -126,8 +132,10 @@ partial class DisplayEditingExtensions {
         return null;
     }
 
-    public static void HighlightCharacterAt<TFont, TGlyph>(this ListDisplay<TFont, TGlyph> self, MathListIndex index, Color color) where TFont : IFont<TGlyph> {
-      if (self.Range.Contains(index.AtomIndex) && self.SubDisplayForIndex(index) is IDisplay<TFont, TGlyph> display)
+    public static void HighlightCharacterAt<TFont, TGlyph>(this ListDisplay<TFont, TGlyph> self,
+      MathListIndex index, Color color) where TFont : IFont<TGlyph> {
+      if (self.Range.Contains(index.AtomIndex)
+        && self.SubDisplayForIndex(index) is IDisplay<TFont, TGlyph> display)
         if (index.SubIndexType is MathListSubIndexType.BetweenBaseAndScripts
             || index.SubIndexType is MathListSubIndexType.None)
           display.HighlightCharacterAt(index, color);
@@ -151,9 +159,9 @@ public static void Highlight<TFont, TGlyph>(this ListDisplay<TFont, TGlyph> self
               && index.AtomIndex == list.IndexInParent
               // This is the right character for the sub/superscript, check that it's type matches the index
               &&
-              (list.LinePosition is Enumerations.LinePosition.Subscript
+              (list.LinePosition is LinePosition.Subscript
                && index.SubIndexType is MathListSubIndexType.Subscript
-               || list.LinePosition is Enumerations.LinePosition.Superscript
+               || list.LinePosition is LinePosition.Superscript
                && index.SubIndexType is MathListSubIndexType.Superscript))
             return list;
           else { }
@@ -178,9 +186,10 @@ public static void Highlight<TFont, TGlyph>(this ListDisplay<TFont, TGlyph> self
               case MathListSubIndexType.Superscript:
               case MathListSubIndexType.Subscript:
               default:
-                throw new InvalidCodePathException("Superscripts and subscripts should have been handled in a separate case above.");
+                throw new InvalidCodePathException
+                  ("Superscripts and subscripts should have been handled in a separate case above.");
             }
       return null;
     }
   }
-}
+}

CSharpMath.Editor/Extensions/MathList.cs

@@ -10,8 +10,7 @@ static void InsertAtAtomIndexAndAdvance(this MathList self, int atomIndex, MathA
       if (atomIndex < 0 || atomIndex > self.Count)
         throw new IndexOutOfRangeException($"Index {atomIndex} is out of bounds for list of size {self.Atoms.Count}");
       // Test for placeholder to the right of index, e.g. \sqrt{‸■} -> \sqrt{2‸}
-      if (atomIndex < self.Count && self[atomIndex] is MathAtom placeholder &&
-          placeholder?.AtomType is Enumerations.MathAtomType.Placeholder) {
+      if (atomIndex < self.Count && self[atomIndex] is Atom.Placeholder placeholder) {
         if (placeholder.Superscript is MathList super) {
           if (atom.Superscript != null) super.Append(atom.Superscript);
           atom.Superscript = super;
@@ -57,7 +56,7 @@ public static void InsertAndAdvance(this MathList self, ref MathListIndex index,
           break;
         case MathListSubIndexType.Degree:
         case MathListSubIndexType.Radicand:
-          if (!(self.Atoms[index.AtomIndex] is Atom.Radical radical && radical.AtomType == Enumerations.MathAtomType.Radical))
+          if (!(self.Atoms[index.AtomIndex] is Atom.Radical radical))
             throw new SubIndexTypeMismatchException(typeof(Atom.Radical), index);
           if (index.SubIndexType == MathListSubIndexType.Degree)
             if (radical.Degree is null) throw new SubIndexTypeMismatchException(index);
@@ -66,8 +65,7 @@ public static void InsertAndAdvance(this MathList self, ref MathListIndex index,
           break;
         case MathListSubIndexType.Numerator:
         case MathListSubIndexType.Denominator:
-          if (!(self.Atoms[index.AtomIndex] is Atom.Fraction frac
-                && frac.AtomType == Enumerations.MathAtomType.Fraction))
+          if (!(self.Atoms[index.AtomIndex] is Atom.Fraction frac))
             throw new SubIndexTypeMismatchException(typeof(Atom.Fraction), index);
           if (index.SubIndexType == MathListSubIndexType.Numerator)
             if (frac.Numerator is null)
@@ -113,12 +111,12 @@ public static void RemoveAt(this MathList self, ref MathListIndex index) {
               self.Atoms[index.AtomIndex - 1] is MathAtom previous &&
               previous.Subscript is null &&
               previous.Superscript is null &&
-              previous.AtomType switch {
-                Enumerations.MathAtomType.BinaryOperator => false,
-                Enumerations.MathAtomType.UnaryOperator => false,
-                Enumerations.MathAtomType.Relation => false,
-                Enumerations.MathAtomType.Punctuation => false,
-                Enumerations.MathAtomType.Space => false,
+              previous switch {
+                Atom.BinaryOperator _ => false,
+                Atom.UnaryOperator _ => false,
+                Atom.Relation _ => false,
+                Atom.Punctuation _ => false,
+                Atom.Space _ => false,
                 _ => true
               }) {
             previous.Superscript = currentAtom.Superscript;
@@ -141,8 +139,7 @@ previous.Superscript is null &&
           return;
         case MathListSubIndexType.Radicand:
         case MathListSubIndexType.Degree:
-          if (!(self.Atoms[index.AtomIndex] is Atom.Radical radical
-                && radical.AtomType == Enumerations.MathAtomType.Radical))
+          if (!(self.Atoms[index.AtomIndex] is Atom.Radical radical))
             throw new SubIndexTypeMismatchException(typeof(Atom.Radical), index);
           if (index.SubIndexType == MathListSubIndexType.Degree)
             if (radical.Degree is null) throw new SubIndexTypeMismatchException(index);
@@ -151,7 +148,7 @@ previous.Superscript is null &&
           break;
         case MathListSubIndexType.Numerator:
         case MathListSubIndexType.Denominator:
-          if (!(self.Atoms[index.AtomIndex] is Atom.Fraction frac && frac.AtomType == Enumerations.MathAtomType.Fraction))
+          if (!(self.Atoms[index.AtomIndex] is Atom.Fraction frac))
             throw new SubIndexTypeMismatchException(typeof(Atom.Fraction), index);
           if (index.SubIndexType == MathListSubIndexType.Numerator)
             if (frac.Numerator is null) throw new SubIndexTypeMismatchException(index);
@@ -196,7 +193,7 @@ public static void RemoveAtoms(this MathList self, MathListRange? nullableRange)
           throw new NotSupportedException("Nuclear fission is not supported");
         case MathListSubIndexType.Radicand:
         case MathListSubIndexType.Degree:
-          if (!(self.Atoms[start.AtomIndex] is Atom.Radical radical && radical.AtomType == Enumerations.MathAtomType.Radical))
+          if (!(self.Atoms[start.AtomIndex] is Atom.Radical radical))
             throw new SubIndexTypeMismatchException(typeof(Atom.Radical), start);
           if (start.SubIndexType == MathListSubIndexType.Degree)
             if (radical.Degree is null)
@@ -206,7 +203,7 @@ public static void RemoveAtoms(this MathList self, MathListRange? nullableRange)
           break;
         case MathListSubIndexType.Numerator:
         case MathListSubIndexType.Denominator:
-          if (!(self.Atoms[start.AtomIndex] is Atom.Fraction frac && frac.AtomType == Enumerations.MathAtomType.Fraction))
+          if (!(self.Atoms[start.AtomIndex] is Atom.Fraction frac))
             throw new SubIndexTypeMismatchException(typeof(Atom.Fraction), start);
           if (start.SubIndexType == MathListSubIndexType.Numerator)
             if (frac.Numerator is null) throw new SubIndexTypeMismatchException(start);
@@ -244,15 +241,15 @@ public static void RemoveAtoms(this MathList self, MathListRange? nullableRange)
         case MathListSubIndexType.Radicand:
         case MathListSubIndexType.Degree:
           return
-            atom is Atom.Radical radical && radical.AtomType == Enumerations.MathAtomType.Radical
+            atom is Atom.Radical radical
             ? index.SubIndexType == MathListSubIndexType.Degree
               ? radical.Degree?.AtomAt(index.SubIndex)
               : radical.Radicand?.AtomAt(index.SubIndex)
             : null;
         case MathListSubIndexType.Numerator:
         case MathListSubIndexType.Denominator:
           return
-            atom is Atom.Fraction frac && frac.AtomType == Enumerations.MathAtomType.Fraction
+            atom is Atom.Fraction frac
             ? index.SubIndexType == MathListSubIndexType.Denominator
               ? frac.Denominator?.AtomAt(index.SubIndex)
               : frac.Numerator?.AtomAt(index.SubIndex)