WIP rebased onto latest master

Happypig375 · Happypig375 · commit b35873ac724a · 2026-02-17T05:13:29.000+08:00
diff --git a/CSharpMath.Core.Tests/Atom/DictionaryTests.cs b/CSharpMath.Core.Tests/Atom/DictionaryTests.cs
@@ -1,7 +1,7 @@
 using CSharpMath.Atom;
 using Xunit;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.AtomTests {
   public class DictionaryTests {
     private AliasBiDictionary<string, int> InitTestDict() =>
       new AliasBiDictionary<string, int> {
diff --git a/CSharpMath.Core.Tests/Atom/LaTeXParserTest.cs b/CSharpMath.Core.Tests/Atom/LaTeXParserTest.cs
@@ -6,7 +6,7 @@
 using CSharpMath.Atom.Atoms;
 using Xunit;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.AtomTests {
   public class LaTeXParserTest {
     public static MathList ParseLaTeX(string latex) {
       var builder = new LaTeXParser(latex);
diff --git a/CSharpMath.Core.Tests/Atom/LaTeXSettingsTests.cs b/CSharpMath.Core.Tests/Atom/LaTeXSettingsTests.cs
@@ -1,6 +1,6 @@
 using System.Linq;
 using Xunit;
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.AtomTests {
   using CSharpMath.Atom;
   using CSharpMath.Atom.Atoms;
   using static LaTeXParserTest;
diff --git a/CSharpMath.Core.Tests/Atom/MathAtomTest.cs b/CSharpMath.Core.Tests/Atom/MathAtomTest.cs
@@ -3,7 +3,7 @@
 using CSharpMath.Atom.Atoms;
 using Xunit;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.AtomTests {
   public class MathAtomTest {
     internal static void CheckClone(MathAtom? original, MathAtom? clone) =>
       MathListTest.CheckClone(original, clone);
diff --git a/CSharpMath.Core.Tests/Atom/MathListTest.cs b/CSharpMath.Core.Tests/Atom/MathListTest.cs
@@ -4,7 +4,7 @@
 using CSharpMath.Atom.Atoms;
 using Xunit;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.AtomTests {
   using Range = Atom.Range;
   public class MathListTest {
     internal static void CheckClone(MathAtom? original, MathAtom? clone) {
diff --git a/CSharpMath.Core.Tests/Display/ApproximateAssertions.cs b/CSharpMath.Core.Tests/Display/ApproximateAssertions.cs
@@ -4,7 +4,7 @@
 using System.Runtime.CompilerServices;
 using Xunit;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.DisplayTests {
   [DebuggerStepThrough] // Debugger should stop at the line that uses these functions
   public static class Approximately {
     const double DefaultTolerance = 0.001;
diff --git a/CSharpMath.Core.Tests/Display/FontChangingTests.cs b/CSharpMath.Core.Tests/Display/FontChangingTests.cs
@@ -1,4 +1,4 @@
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.DisplayTests {
   using Atom;
   using Xunit;
   public class FontChangingTests {
diff --git a/CSharpMath.Core.Tests/Display/MockTests.cs b/CSharpMath.Core.Tests/Display/MockTests.cs
@@ -2,7 +2,7 @@
 using Xunit;
 using TGlyph = System.Text.Rune;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.DisplayTests {
   using BackEnd;
   // purpose of this class is to make sure our mocks behave as expected.
   public class MockTests {
diff --git a/CSharpMath.Core.Tests/Display/TypesetterTests.cs b/CSharpMath.Core.Tests/Display/TypesetterTests.cs
@@ -8,10 +8,10 @@
 using TFont = CSharpMath.Core.BackEnd.TestFont;
 using TGlyph = System.Text.Rune;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.DisplayTests {
   public class TypesetterTests {
     internal static ListDisplay<TFont, TGlyph> ParseLaTeXToDisplay(string latex) =>
-      Typesetter.CreateLine(LaTeXParserTest.ParseLaTeX(latex), _font, _context, LineStyle.Display);
+      Typesetter.CreateLine(AtomTests.LaTeXParserTest.ParseLaTeX(latex), _font, _context, LineStyle.Display);
 
     private static readonly TFont _font = new TFont(20);
     private static readonly TypesettingContext<TFont, TGlyph> _context = BackEnd.TestTypesettingContext.Instance;
diff --git a/CSharpMath.Core.Tests/Editor/CaretTests.cs b/CSharpMath.Core.Tests/Editor/CaretTests.cs
@@ -3,7 +3,7 @@
 using Xunit;
 using TGlyph = System.Text.Rune;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.EditorTests {
   using Atom;
   using BackEnd;
   using Editor;
@@ -212,7 +212,7 @@ public void ShowRestingPlaceholdersOnCaretVisible() {
       Assert.True(keyboard.InsertionPositionHighlighted);
       Assert.False(keyboard.ShouldDrawCaret);
 
-      keyboard.InsertionIndex = MathListIndex.Level0Index(keyboard.MathList.Count);
+      keyboard.InsertionIndex = new MathListIndex(keyboard.MathList.Count);
       Assert.True(keyboard.InsertionPositionHighlighted);
       Assert.True(keyboard.ShouldDrawCaret);
       Assert.Equal(LaTeXSettings.PlaceholderRestingNucleus, outer.Nucleus);
diff --git a/CSharpMath.Core.Tests/Editor/IndexForPointTests.cs b/CSharpMath.Core.Tests/Editor/IndexForPointTests.cs
@@ -1,7 +1,7 @@
 using System.Drawing;
 using Xunit;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.EditorTests {
   using Atom;
   using BackEnd;
   using Editor;
@@ -14,18 +14,13 @@ public void Add((double x, double y) point,
         int index, params (SubIndex subType, int subIndex)[] subIndexRecursive) {
         switch (subIndexRecursive.Length) {
           case 0:
-            var mathListIndex = MathListIndex.Level0Index(index);
+            var mathListIndex = new MathListIndex(index);
             goto default;
           case var _:
-            mathListIndex = MathListIndex.Level0Index(
-              subIndexRecursive[^1].subIndex);
+            mathListIndex = new(subIndexRecursive[^1].subIndex);
             for (var i = subIndexRecursive.Length - 2; i >= 0; i--)
-              mathListIndex = MathListIndex.IndexAtLocation(
-                subIndexRecursive[i].subIndex,
-                subIndexRecursive[i + 1].subType,
-                mathListIndex);
-            mathListIndex = MathListIndex.IndexAtLocation(index,
-              subIndexRecursive[0].subType, mathListIndex);
+              mathListIndex = mathListIndex.WrapInIndex(subIndexRecursive[i].subIndex, subIndexRecursive[i + 1].subType);
+            mathListIndex = mathListIndex.WrapInIndex(index, subIndexRecursive[0].subType);
             goto default;
           default:
             Add(new PointF((float)point.x, (float)point.y), mathListIndex);
diff --git a/CSharpMath.Core.Tests/Editor/KeyPressTests.cs b/CSharpMath.Core.Tests/Editor/KeyPressTests.cs
@@ -7,7 +7,7 @@
 using T = Xunit.InlineDataAttribute;
 using TGlyph = System.Text.Rune;
 
-namespace CSharpMath.Core.Tests {
+namespace CSharpMath.Core.EditorTests {
   using BackEnd;
   using Editor;
   public class KeyPressTests {
diff --git a/CSharpMath.Core.Tests/Editor/PointForIndexTests.cs b/CSharpMath.Core.Tests/Editor/PointForIndexTests.cs
@@ -1,8 +1,8 @@
 using System.Drawing;
 using Xunit;
 
-namespace CSharpMath.Core.Tests {
-  using Atom;
+namespace CSharpMath.Core.EditorTests {
+  using DisplayTests;
   using BackEnd;
   using Editor;
   using static IndexForPointTests;
diff --git a/CSharpMath.Rendering.Tests/TestRendering.cs b/CSharpMath.Rendering.Tests/TestRendering.cs
@@ -163,7 +163,7 @@ protected void Run<TContent>(
         return;
       }
 
-      Core.Tests.Approximately.Equal(expectedStream.Length, actualStream.Length, expectedStream.Length * FileSizeTolerance);
+      DisplayTests.Approximately.Equal(expectedStream.Length, actualStream.Length, expectedStream.Length * FileSizeTolerance);
       if (FileSizeTolerance == 0)
         Assert.True(contentsMatch, "The images differ.");
     }
diff --git a/CSharpMath/Atom/MathList.cs b/CSharpMath/Atom/MathList.cs
@@ -19,7 +19,7 @@ public class MathList : IMathObject, IList<MathAtom>, IReadOnlyList<MathAtom>, I
     public MathList(params MathAtom[] atoms) => Atoms = new List<MathAtom>(atoms);
 
     /// <returns>The last <see cref="MathAtom"/> that is not a <see cref="Comment"/>,
-    /// or <see cref="null"/> when <see cref="Atoms"/> is empty.</returns>
+    /// or <see langword="null"/> when <see cref="Atoms"/> is empty.</returns>
 #if !NETSTANDARD2_0 && !NET45
     [System.Diagnostics.CodeAnalysis.DisallowNull]
 #endif
diff --git a/CSharpMath/Editor/Extensions/FractionDisplay.cs b/CSharpMath/Editor/Extensions/FractionDisplay.cs
@@ -5,32 +5,30 @@ namespace CSharpMath.Editor {
   using Display.FrontEnd;
 
   partial class Extensions {
-    public static MathListIndex IndexForPoint<TFont, TGlyph>(
+    public static MathListIndex? IndexForPoint<TFont, TGlyph>(
       this FractionDisplay<TFont, TGlyph> self,
       TypesettingContext<TFont, TGlyph> context,
       PointF point) where TFont : IFont<TGlyph> =>
       // We can be before or after the fraction
       point.X < self.Position.X - PixelDelta
-      //We are before the fraction, so
-      ? MathListIndex.Level0Index(self.Range.Location)
+      // We are before the fraction
+      ? new(self.Range.Location)
       : point.X > self.Position.X + self.Width + PixelDelta
-      //We are after the fraction
-      ? MathListIndex.Level0Index(self.Range.End)
+      // We are after the fraction
+      ? new(self.Range.End)
       : point.Y > self.LinePosition + PixelDelta
-      ? MathListIndex.IndexAtLocation(self.Range.Location,
-          MathListSubIndexType.Numerator, self.Numerator.IndexForPoint(context, point))
+      ? self.Numerator.IndexForPoint(context, point)?.WrapInIndex(self.Range.Location, MathListSubIndexType.Numerator)
       : point.Y < self.LinePosition - PixelDelta
-      ? MathListIndex.IndexAtLocation(self.Range.Location,
-          MathListSubIndexType.Denominator, self.Denominator.IndexForPoint(context, point))
+      ? self.Denominator.IndexForPoint(context, point)?.WrapInIndex(self.Range.Location, MathListSubIndexType.Denominator)
       : point.X > self.Position.X + self.Width / 2
-      ? MathListIndex.Level0Index(self.Range.End)
-      : MathListIndex.Level0Index(self.Range.Location);
+      ? new(self.Range.End)
+      : new(self.Range.Location);
 
     public static PointF? PointForIndex<TFont, TGlyph>(
       this FractionDisplay<TFont, TGlyph> self,
       TypesettingContext<TFont, TGlyph> _,
       MathListIndex index) where TFont : IFont<TGlyph> =>
-      index.SubIndexType != MathListSubIndexType.None
+      index.SubIndexInfo is { }
       ? throw new ArgumentException
         ("The subindex must be none to get the closest point for it.", nameof(index))
       : index.AtomIndex == self.Range.End
@@ -42,7 +40,7 @@ public static MathListIndex IndexForPoint<TFont, TGlyph>(
     public static void HighlightCharacterAt<TFont, TGlyph>(
       this FractionDisplay<TFont, TGlyph> self,
       MathListIndex index, Color color) where TFont : IFont<TGlyph> {
-      if (index.SubIndexType != MathListSubIndexType.None)
+      if (index.SubIndexInfo is { })
         throw new ArgumentException
           ("The subindex must be none to get the highlight a character in it.", nameof(index));
       self.Highlight(color);
diff --git a/CSharpMath/Editor/Extensions/IGlyphDisplay.cs b/CSharpMath/Editor/Extensions/IGlyphDisplay.cs
@@ -10,14 +10,14 @@ public static MathListIndex IndexForPoint<TFont, TGlyph>(
       TypesettingContext<TFont, TGlyph> _,
       PointF point) where TFont : IFont<TGlyph> =>
       point.X > self.Position.X + self.Width / 2
-      ? MathListIndex.Level0Index(self.Range.End)
-      : MathListIndex.Level0Index(self.Range.Location);
+      ? new(self.Range.End)
+      : new(self.Range.Location);
 
     public static PointF? PointForIndex<TFont, TGlyph>(
       this IGlyphDisplay<TFont, TGlyph> self,
       TypesettingContext<TFont, TGlyph> _,
       MathListIndex index) where TFont : IFont<TGlyph> =>
-      index.SubIndexType != MathListSubIndexType.None
+      index.SubIndexInfo is { }
       ? throw new ArgumentException
         ("The subindex must be none to get the closest point for it.", nameof(index))
       : index.AtomIndex == self.Range.End
@@ -29,7 +29,7 @@ public static MathListIndex IndexForPoint<TFont, TGlyph>(
     public static void HighlightCharacterAt<TFont, TGlyph>(
       this IGlyphDisplay<TFont, TGlyph> self,
       MathListIndex index, Color color) where TFont : IFont<TGlyph> {
-      if (index.SubIndexType != MathListSubIndexType.None)
+      if (index.SubIndexInfo is { })
         throw new ArgumentException
           ("The subindex must be none to get the highlight a character in it.", nameof(index));
       self.Highlight(color);
diff --git a/CSharpMath/Editor/Extensions/InnerDisplay.cs b/CSharpMath/Editor/Extensions/InnerDisplay.cs
@@ -5,25 +5,24 @@ namespace CSharpMath.Editor {
   using Display.FrontEnd;
 
   partial class Extensions {
-    public static MathListIndex IndexForPoint<TFont, TGlyph>(
+    public static MathListIndex? IndexForPoint<TFont, TGlyph>(
       this InnerDisplay<TFont, TGlyph> self,
       TypesettingContext<TFont, TGlyph> context,
       PointF point) where TFont : IFont<TGlyph> =>
       // We can be before or after the inner
       point.X < self.Position.X + (self.Left?.Width / 2 ?? 0)
       //We are before the inner, so
-      ? MathListIndex.Level0Index(self.Range.Location)
+      ? new(self.Range.Location)
       : point.X > self.Position.X + self.Width - (self.Right?.Width / 2 ?? 0)
       //We are after the inner
-      ? MathListIndex.Level0Index(self.Range.End)
-      : MathListIndex.IndexAtLocation(self.Range.Location,
-          MathListSubIndexType.Inner, self.Inner.IndexForPoint(context, point));
+      ? new(self.Range.End)
+      : self.Inner.IndexForPoint(context, point)?.WrapInIndex(self.Range.Location, MathListSubIndexType.Inner);
 
     public static PointF? PointForIndex<TFont, TGlyph>(
       this InnerDisplay<TFont, TGlyph> self,
       TypesettingContext<TFont, TGlyph> _,
       MathListIndex index) where TFont : IFont<TGlyph> =>
-      index.SubIndexType != MathListSubIndexType.None
+      index.SubIndexInfo is { }
       ? throw new ArgumentException
         ("The subindex must be none to get the closest point for it.", nameof(index))
       : index.AtomIndex == self.Range.End
@@ -35,7 +34,7 @@ public static MathListIndex IndexForPoint<TFont, TGlyph>(
     public static void HighlightCharacterAt<TFont, TGlyph>(
       this InnerDisplay<TFont, TGlyph> self,
       MathListIndex index, Color color) where TFont : IFont<TGlyph> {
-      if (index.SubIndexType != MathListSubIndexType.None)
+      if (index.SubIndexInfo is { })
         throw new ArgumentException
           ("The subindex must be none to get the highlight a character in it.", nameof(index));
       self.Highlight(color);
diff --git a/CSharpMath/Editor/Extensions/LargeOpLimitsDisplay.cs b/CSharpMath/Editor/Extensions/LargeOpLimitsDisplay.cs
@@ -6,35 +6,32 @@ namespace CSharpMath.Editor {
   using Display.FrontEnd;
 
   partial class Extensions {
-    public static MathListIndex IndexForPoint<TFont, TGlyph>(
+    public static MathListIndex? IndexForPoint<TFont, TGlyph>(
       this LargeOpLimitsDisplay<TFont, TGlyph> self,
       TypesettingContext<TFont, TGlyph> context,
       PointF point) where TFont : IFont<TGlyph> =>
       // We can be before or after the large operator
       point.X < self.Position.X - PixelDelta
       // We are before the large operator, so
-      ? MathListIndex.Level0Index(self.Range.Location)
+      ? new(self.Range.Location)
       : point.X > self.Position.X + self.Width + PixelDelta
       // We are after the large operator
-      ? MathListIndex.Level0Index(self.Range.End)
+      ? new(self.Range.End)
       : self.UpperLimit is { } u && point.Y > self.Position.Y + u.Position.Y - PixelDelta
-      ? MathListIndex.IndexAtLocation(self.Range.Location,
-          MathListSubIndexType.Superscript, u.IndexForPoint(context, point))
+      ? u.IndexForPoint(context, point)?.WrapInIndex(self.Range.Location, MathListSubIndexType.Superscript)
       : self.LowerLimit is { } l && point.Y < self.Position.Y + l.Position.Y + l.DisplayBounds().Height + PixelDelta
-      ? MathListIndex.IndexAtLocation(self.Range.Location,
-          MathListSubIndexType.Subscript, l.IndexForPoint(context, point))
+      ? l.IndexForPoint(context, point)?.WrapInIndex(self.Range.Location, MathListSubIndexType.Subscript)
       : point.X > self.Position.X + self.Width * 3 / 4
-      ? MathListIndex.Level0Index(self.Range.End)
+      ? new(self.Range.End)
       : point.X > self.Position.X + self.Width / 2
-      ? MathListIndex.IndexAtLocation(self.Range.Location,
-        MathListSubIndexType.BetweenBaseAndScripts, MathListIndex.Level0Index(1))
-      : MathListIndex.Level0Index(self.Range.Location);
+      ? new(self.Range.Location, new(MathListSubIndexType.BetweenBaseAndScripts, new(1)))
+      : new(self.Range.Location);
 
     public static PointF? PointForIndex<TFont, TGlyph>(
       this LargeOpLimitsDisplay<TFont, TGlyph> self,
       TypesettingContext<TFont, TGlyph> _,
       MathListIndex index) where TFont : IFont<TGlyph> =>
-      index.SubIndexType != MathListSubIndexType.None
+      index.SubIndexInfo is { }
       ? throw new ArgumentException
         ("The subindex must be none to get the closest point for it.", nameof(index))
       : index.AtomIndex == self.Range.End
@@ -46,7 +43,7 @@ public static MathListIndex IndexForPoint<TFont, TGlyph>(
     public static void HighlightCharacterAt<TFont, TGlyph>(
       this LargeOpLimitsDisplay<TFont, TGlyph> self,
       MathListIndex index, Color color) where TFont : IFont<TGlyph> {
-      if (index.SubIndexType != MathListSubIndexType.None)
+      if (index.SubIndexInfo is { })
         throw new ArgumentException
           ("The subindex must be none to get the highlight a character in it.", nameof(index));
       self.Highlight(color);
diff --git a/CSharpMath/Editor/Extensions/ListDisplay.cs b/CSharpMath/Editor/Extensions/ListDisplay.cs
diff --git a/CSharpMath/Editor/Extensions/MathList.cs b/CSharpMath/Editor/Extensions/MathList.cs
diff --git a/CSharpMath/Editor/Extensions/RadicalDisplay.cs b/CSharpMath/Editor/Extensions/RadicalDisplay.cs
diff --git a/CSharpMath/Editor/Extensions/TextLineDisplay.cs b/CSharpMath/Editor/Extensions/TextLineDisplay.cs
diff --git a/CSharpMath/Editor/MathKeyboard.cs b/CSharpMath/Editor/MathKeyboard.cs
diff --git a/CSharpMath/Editor/MathListIndex.cs b/CSharpMath/Editor/MathListIndex.cs
diff --git a/CSharpMath/Editor/MathListRange.cs b/CSharpMath/Editor/MathListRange.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-namespace CSharpMath.Core.Tests {`
	`1`	`+namespace CSharpMath.Core.DisplayTests {`
`2`	`2`	`using Atom;`
`3`	`3`	`using Xunit;`
`4`	`4`	`public class FontChangingTests {`