Make blinking Placeholder's Nucleus and ForeColor customizable in both CaretStates

CSharpMath.CoreTests/MockTests.cs

@@ -12,16 +12,17 @@ public void TestGlyphBoundsWithoutM() {
       var font = new TestFont(10);
       var provider = TestGlyphBoundsProvider.Instance;
       var glyphRun = new AttributedGlyphRun<TestFont, TGlyph>(hello, hello, font);
+      Assert.All(glyphRun.GlyphInfos, glyphInfo => Assert.Null(glyphInfo.Foreground));
       var width = provider.GetTypographicWidth(font, glyphRun);
       Approximately.Equal(width, 25,  0.01);
     }
-
     [Fact]
     public void TestGlyphBoundsWithM() {
       string america = "America";
       var font = new TestFont(10);
       var provider = TestGlyphBoundsProvider.Instance;
       var glyphRun = new AttributedGlyphRun<TestFont, TGlyph>(america, america, font);
+      Assert.All(glyphRun.GlyphInfos, glyphInfo => Assert.Null(glyphInfo.Foreground));
       var width = provider.GetTypographicWidth(font, glyphRun);
       Approximately.Equal(width, 40, 0.01);
     }

CSharpMath.Editor.Tests/CaretTests.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
+using CSharpMath.Atom;
 using CSharpMath.CoreTests.FrontEnd;
 using Xunit;
 
@@ -32,18 +32,18 @@ public async Task Test() {
       var outer = Assert.IsType<Atom.Atoms.Placeholder>(Assert.Single(keyboard.MathList));
       var inner = Assert.IsType<Atom.Atoms.Placeholder>(Assert.Single(outer.Superscript));
       Assert.Equal(MathKeyboardCaretState.ShownThroughPlaceholder, keyboard.CaretState);
-      Assert.Equal("\u25A1", outer.Nucleus);
-      Assert.Equal("\u25A0", inner.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, outer.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.ActiveNucleus, inner.Nucleus);
 
       await Task.Delay((int)MathKeyboard<TestFont, char>.DefaultBlinkMilliseconds + CaretBlinks.MillisecondBuffer);
       Assert.Equal(MathKeyboardCaretState.TemporarilyHidden, keyboard.CaretState);
-      Assert.Equal("\u25A1", outer.Nucleus);
-      Assert.Equal("\u25A1", inner.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, outer.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, inner.Nucleus);
 
       await Task.Delay((int)MathKeyboard<TestFont, char>.DefaultBlinkMilliseconds + CaretBlinks.MillisecondBuffer);
       Assert.Equal(MathKeyboardCaretState.ShownThroughPlaceholder, keyboard.CaretState);
-      Assert.Equal("\u25A1", outer.Nucleus);
-      Assert.Equal("\u25A0", inner.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, outer.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.ActiveNucleus, inner.Nucleus);
     }
   }
   public class CaretMovesWithPlaceholder {
@@ -58,20 +58,20 @@ public async Task Test() {
       var outer = Assert.IsType<Atom.Atoms.Placeholder>(Assert.Single(keyboard.MathList));
       var inner = Assert.IsType<Atom.Atoms.Placeholder>(Assert.Single(outer.Subscript));
       Assert.Equal(MathKeyboardCaretState.ShownThroughPlaceholder, keyboard.CaretState);
-      Assert.Equal("\u25A1", outer.Nucleus);
-      Assert.Equal("\u25A0", inner.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, outer.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.ActiveNucleus, inner.Nucleus);
 
       await Task.Delay((int)MathKeyboard<TestFont, char>.DefaultBlinkMilliseconds + CaretBlinks.MillisecondBuffer);
       Assert.Equal(MathKeyboardCaretState.TemporarilyHidden, keyboard.CaretState);
       keyboard.KeyPress(MathKeyboardInput.Left);
       Assert.Equal(MathKeyboardCaretState.ShownThroughPlaceholder, keyboard.CaretState);
-      Assert.Equal("\u25A0", outer.Nucleus);
-      Assert.Equal("\u25A1", inner.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.ActiveNucleus, outer.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, inner.Nucleus);
 
       Assert.Equal(MathKeyboardCaretState.ShownThroughPlaceholder, keyboard.CaretState);
       keyboard.KeyPress(MathKeyboardInput.Right);
-      Assert.Equal("\u25A1", outer.Nucleus);
-      Assert.Equal("\u25A0", inner.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, outer.Nucleus);
+      Assert.Equal(DefaultPlaceholderSettings.ActiveNucleus, inner.Nucleus);
     }
   }
   public class CaretStaysHidden {
@@ -176,4 +176,101 @@ public async Task Test() {
       Assert.Equal(MathKeyboardCaretState.Shown, keyboard.CaretState);
     }
   }
+  public class DefaultPlaceholderSettings {
+    public const string ActiveNucleus = "■";
+    public const string RestingNucleus = "□";
+    public static readonly System.Drawing.Color? ActiveColor = null;
+    public static readonly System.Drawing.Color? RestingColor = null;
+  }
+  [CollectionDefinition(nameof(NonParallelPlaceholderTests), DisableParallelization = true)]
+  public class NonParallelPlaceholderTests { }
+  [Collection(nameof(NonParallelPlaceholderTests))]
+  public class DefaultPlaceholder {
+    [Fact]
+    public void LaTeXSettingsPlaceholderIsNewInstance() {
+      Assert.NotSame(LaTeXSettings.Placeholder, LaTeXSettings.Placeholder);
+      // Double check, also verify that its contents are 'fresh':
+      LaTeXSettings.Placeholder.Nucleus = "x";
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, LaTeXSettings.Placeholder.Nucleus);
+      LaTeXSettings.Placeholder.Color = System.Drawing.Color.Green;
+      Assert.Equal(DefaultPlaceholderSettings.RestingColor, LaTeXSettings.Placeholder.Color);
+    }
+    [Fact]
+    public void DefaultPlaceholderAppearance() {
+      Assert.Null(LaTeXSettings.PlaceholderActiveColor);
+      Assert.Null(LaTeXSettings.PlaceholderRestingColor);
+      Assert.Equal(DefaultPlaceholderSettings.ActiveNucleus, LaTeXSettings.PlaceholderActiveNucleus);
+      Assert.Equal(DefaultPlaceholderSettings.RestingNucleus, LaTeXSettings.PlaceholderRestingNucleus);
+      Assert.Equal(LaTeXSettings.PlaceholderRestingNucleus, LaTeXSettings.Placeholder.Nucleus);
+      Assert.Equal(LaTeXSettings.PlaceholderRestingColor, LaTeXSettings.Placeholder.Color);
+    }
+  }
+  [Collection(nameof(NonParallelPlaceholderTests))]
+  public class CustomizablePlaceholder : IDisposable {
+    public CustomizablePlaceholder() {
+      LaTeXSettings.PlaceholderActiveNucleus = "😀";
+      LaTeXSettings.PlaceholderRestingNucleus = "😐";
+      LaTeXSettings.PlaceholderActiveColor = System.Drawing.Color.Green;
+      LaTeXSettings.PlaceholderRestingColor = System.Drawing.Color.Blue;
+    }
+    public void Dispose() {
+      LaTeXSettings.PlaceholderActiveNucleus = DefaultPlaceholderSettings.ActiveNucleus;
+      LaTeXSettings.PlaceholderRestingNucleus = DefaultPlaceholderSettings.RestingNucleus;
+      LaTeXSettings.PlaceholderActiveColor = DefaultPlaceholderSettings.ActiveColor;
+      LaTeXSettings.PlaceholderRestingColor = DefaultPlaceholderSettings.RestingColor;
+    }
+    [Fact]
+    public async Task CustomizedPlaceholderBlinks() {
+      var keyboard = new MathKeyboard<TestFont, char>(TestTypesettingContexts.Instance, new TestFont()) {
+        CaretState = MathKeyboardCaretState.Shown
+      };
+      Assert.Equal(MathKeyboardCaretState.Shown, keyboard.CaretState);
+
+      keyboard.KeyPress(MathKeyboardInput.Subscript);
+      var outer = Assert.IsType<Atom.Atoms.Placeholder>(Assert.Single(keyboard.MathList));
+      var inner = Assert.IsType<Atom.Atoms.Placeholder>(Assert.Single(outer.Subscript));
+      Assert.Equal(MathKeyboardCaretState.ShownThroughPlaceholder, keyboard.CaretState);
+      Assert.Equal("😐", outer.Nucleus);
+      Assert.Equal(System.Drawing.Color.Blue, outer.Color);
+      Assert.Equal("😀", inner.Nucleus);
+      Assert.Equal(System.Drawing.Color.Green, inner.Color);
+
+      await Task.Delay((int)MathKeyboard<TestFont, char>.DefaultBlinkMilliseconds + CaretBlinks.MillisecondBuffer);
+      Assert.Equal(MathKeyboardCaretState.TemporarilyHidden, keyboard.CaretState);
+      Assert.Equal("😐", outer.Nucleus);
+      Assert.Equal(System.Drawing.Color.Blue, outer.Color);
+      Assert.Equal("😐", inner.Nucleus);
+      Assert.Equal(System.Drawing.Color.Blue, inner.Color);
+
+      await Task.Delay((int)MathKeyboard<TestFont, char>.DefaultBlinkMilliseconds + CaretBlinks.MillisecondBuffer);
+      Assert.Equal(MathKeyboardCaretState.ShownThroughPlaceholder, keyboard.CaretState);
+      Assert.Equal("😐", outer.Nucleus);
+      Assert.Equal(System.Drawing.Color.Blue, outer.Color);
+      Assert.Equal("😀", inner.Nucleus);
+      Assert.Equal(System.Drawing.Color.Green, inner.Color);
+    }
+    [Fact]
+    public void AllCustomizablePlaceholderPropertiesAreResetOnCaretVisible() {
+      var keyboard = new MathKeyboard<TestFont, char>(TestTypesettingContexts.Instance, new TestFont()) {
+        CaretState = MathKeyboardCaretState.Shown
+      };
+      Assert.Equal(MathKeyboardCaretState.Shown, keyboard.CaretState);
+      keyboard.KeyPress(MathKeyboardInput.Subscript);
+      var outer = Assert.IsType<Atom.Atoms.Placeholder>(Assert.Single(keyboard.MathList));
+      var inner = Assert.IsType<Atom.Atoms.Placeholder>(Assert.Single(outer.Subscript));
+      Assert.Equal(MathKeyboardCaretState.ShownThroughPlaceholder, keyboard.CaretState);
+
+      keyboard.InsertionIndex = MathListIndex.Level0Index(keyboard.MathList.Count);
+      Assert.Equal(MathKeyboardCaretState.Shown, keyboard.CaretState);
+      Assert.Equal(LaTeXSettings.PlaceholderRestingNucleus, outer.Nucleus);
+      Assert.Equal(LaTeXSettings.PlaceholderRestingColor, outer.Color);
+      Assert.Equal(LaTeXSettings.PlaceholderRestingNucleus, inner.Nucleus);
+      Assert.Equal(LaTeXSettings.PlaceholderRestingColor, inner.Color);
+    }
+    [Fact]
+    public void CustomizedPlaceholderGetter() {
+      Assert.Equal("😐", LaTeXSettings.Placeholder.Nucleus);
+      Assert.Equal(System.Drawing.Color.Blue, LaTeXSettings.Placeholder.Color);
+    }
+  }
 }

CSharpMath.Editor/MathKeyboard.cs

@@ -44,8 +44,9 @@ static void ResetPlaceholders(MathList mathList) {
         ResetPlaceholders(mathAtom.Superscript);
         ResetPlaceholders(mathAtom.Subscript);
         switch (mathAtom) {
-          case Atoms.Placeholder _:
-            mathAtom.Nucleus = "\u25A1";
+          case Atoms.Placeholder placeholder:
+            placeholder.Color = LaTeXSettings.PlaceholderRestingColor;
+            placeholder.Nucleus = LaTeXSettings.PlaceholderRestingNucleus;
             break;
           case IMathListContainer container:
             foreach (var list in container.InnerLists)
@@ -62,10 +63,10 @@ public MathKeyboardCaretState CaretState {
         blinkTimer.Start();
         if (value != MathKeyboardCaretState.Hidden &&
            MathList.AtomAt(_insertionIndex) is Atoms.Placeholder placeholder) 
-          (placeholder.Nucleus, _caretState) =
+          (placeholder.Nucleus, placeholder.Color, _caretState) =
             value == MathKeyboardCaretState.TemporarilyHidden
-            ? ("\u25A1", MathKeyboardCaretState.TemporarilyHidden)
-            : ("\u25A0", MathKeyboardCaretState.ShownThroughPlaceholder);
+            ? (LaTeXSettings.PlaceholderRestingNucleus, LaTeXSettings.PlaceholderRestingColor, MathKeyboardCaretState.TemporarilyHidden)
+            : (LaTeXSettings.PlaceholderActiveNucleus, LaTeXSettings.PlaceholderActiveColor, MathKeyboardCaretState.ShownThroughPlaceholder);
         else _caretState = value;
         RecreateDisplayFromMathList();
         RedrawRequested?.Invoke(this, EventArgs.Empty);

CSharpMath/Atom/Atoms/Placeholder.cs

@@ -1,9 +1,11 @@
+using System.Drawing;
 namespace CSharpMath.Atom.Atoms {
   /// <summary>A placeholder for future input</summary>
   public sealed class Placeholder : MathAtom {
-    public Placeholder(string nucleus) : base(nucleus) { }
+    public Color? Color { get; set; }
+    public Placeholder(string nucleus, Color? color) : base(nucleus) => Color = color;
     public override bool ScriptsAllowed => true;
     public new Placeholder Clone(bool finalize) => (Placeholder)base.Clone(finalize);
-    protected override MathAtom CloneInside(bool finalize) => new Placeholder(Nucleus);
+    protected override MathAtom CloneInside(bool finalize) => new Placeholder(Nucleus, Color);
   }
 }

CSharpMath/Atom/LaTeXSettings.cs

@@ -320,7 +320,11 @@ public static class LaTeXSettings {
       };
     public static MathAtom Times => new BinaryOperator("×");
     public static MathAtom Divide => new BinaryOperator("÷");
-    public static MathAtom Placeholder => new Placeholder("\u25A1");
+    public static Color? PlaceholderRestingColor { get; set; }
+    public static Color? PlaceholderActiveColor { get; set; }
+    public static string PlaceholderActiveNucleus { get; set; } = "\u25A0";
+    public static string PlaceholderRestingNucleus { get; set; } = "\u25A1";
+    public static Placeholder Placeholder => new Placeholder(PlaceholderRestingNucleus, PlaceholderRestingColor);
     public static MathList PlaceholderList => new MathList { Placeholder };
 
     public static AliasBiDictionary<string, FontStyle> FontStyles { get; } =

CSharpMath/Display/AttributedGlyphRun.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 using System.Text;
 
@@ -7,9 +8,9 @@ namespace CSharpMath.Display {
   /// over the whole string. We use KernedGlyph objects instead of Glyphs to
   /// allow us to set kern on a per-glyph basis.</summary>
   public class AttributedGlyphRun<TFont, TGlyph> where TFont : FrontEnd.IFont<TGlyph> {
-    public AttributedGlyphRun(string text, IEnumerable<TGlyph> glyphs, TFont font, bool isPlaceHolder = false) {
+    public AttributedGlyphRun(string text, IEnumerable<TGlyph> glyphs, TFont font, bool isPlaceHolder = false, Color? color = null) {
       Text = new StringBuilder(text);
-      GlyphInfos = glyphs.Select(g => new GlyphInfo<TGlyph>(g)).ToList();
+      GlyphInfos = glyphs.Select(g => new GlyphInfo<TGlyph>(g) { Foreground = color }).ToList();
       Font = font;
       Placeholder = isPlaceHolder;
     }

CSharpMath/Display/Typesetter.cs

@@ -337,7 +337,7 @@ private void CreateDisplayAtoms(List<MathAtom> preprocessedAtoms) {
               var nucleusText = atom.Nucleus;
               var glyphs = _context.GlyphFinder.FindGlyphs(_font, nucleusText);
               var current = new AttributedGlyphRun<TFont, TGlyph>(
-                nucleusText, glyphs, _font, atom is Placeholder);
+                nucleusText, glyphs, _font, atom is Placeholder, (atom as Placeholder)?.Color);
               _currentLine.AppendGlyphRun(current);
               if (_currentLineIndexRange.Location == Range.UndefinedInt)
                 _currentLineIndexRange = atom.IndexRange;