public Painter(float fontSize = DefaultFontSize)
{
Fonts = new TFonts(Array.Empty <Typeface>(), fontSize);
LocalTypefaces.CollectionChanged += TypefacesChanged;
ErrorColor = UnwrapColor(new Color(255, 0, 0));
TextColor = UnwrapColor(new Color(0, 0, 0));
HighlightColor = UnwrapColor(new Color(0, 0, 0, 0));
}
public static (Displays relative, Displays absolute) Layout(TextAtom input, Fonts inputFont, float canvasWidth, float additionalLineSpacing)
{
#warning Multiply these constants by resolution
const float abovedisplayskip = 12, abovedisplayshortskip = 0, belowdisplayskip = 12, belowdisplayshortskip = 7;
if (input == null)
{
return
(new Displays(Array.Empty <IDisplay <Fonts, Glyph> >()),
new Displays(Array.Empty <IDisplay <Fonts, Glyph> >()));
}
float accumulatedHeight = 0;
bool afterDisplayMaths = false; //indicator of the need to apply belowdisplay(short)skip when line break
void BreakLine(TextDisplayLineBuilder line, List <IDisplay <Fonts, Glyph> > displayList, List <IDisplay <Fonts, Glyph> > displayMathList, bool appendLineGap = true)
{
if (afterDisplayMaths)
{
accumulatedHeight += line.Width > displayMathList.Last().Position.X ? belowdisplayskip : belowdisplayshortskip;
afterDisplayMaths = false;
}
line.Clear(0, -accumulatedHeight, displayList, ref accumulatedHeight, true, appendLineGap, additionalLineSpacing);
}
//variables captured by this method are currently unchangable by TextAtoms
void AddDisplaysWithLineBreaks(
TextAtom atom,
Fonts fonts,
TextDisplayLineBuilder line,
List <IDisplay <Fonts, Glyph> > displayList,
List <IDisplay <Fonts, Glyph> > displayMathList,
FontStyle style,
Structures.Color?color
)
{
IDisplay <Fonts, Glyph> display;
switch (atom)
{
case TextAtom.List list:
foreach (var a in list.Content)
{
AddDisplaysWithLineBreaks(a, fonts, line, displayList, displayMathList, style, color);
}
break;
case TextAtom.Style st:
AddDisplaysWithLineBreaks(st.Content, fonts, line, displayList, displayMathList, st.FontStyle, color);
break;
case TextAtom.Size sz:
AddDisplaysWithLineBreaks(sz.Content, new Fonts(fonts, sz.PointSize), line, displayList, displayMathList, style, color);
break;
case TextAtom.Color c:
AddDisplaysWithLineBreaks(c.Content, fonts, line, displayList, displayMathList, style, c.Colour);
break;
case TextAtom.Space sp:
//Allow space at start of line since user explicitly specified its length
//Also \par generates this kind of spaces
line.AddSpace(sp.Content.ActualLength(MathTable.Instance, fonts));
break;
case TextAtom.Newline n:
BreakLine(line, displayList, displayMathList);
break;
case TextAtom.Math m when m.DisplayStyle:
var lastLineWidth = line.Width;
BreakLine(line, displayList, displayMathList, false);
display = Typesetter <Fonts, Glyph> .CreateLine(m.Content, fonts, TypesettingContext.Instance, LineStyle.Display);
var displayX = IPainterExtensions.GetDisplayPosition(display.Width, display.Ascent, display.Descent, fonts.PointSize, false, canvasWidth, float.NaN, TextAlignment.Top, default, default, default).X;
//\because When displayList.LastOrDefault() is null, the false condition is selected
//\therefore Append abovedisplayshortskip which defaults to 0 when nothing is above the display-style maths
accumulatedHeight += lastLineWidth > displayX ? abovedisplayskip : abovedisplayshortskip;
accumulatedHeight += display.Ascent;
display.Position = new System.Drawing.PointF(displayX, -accumulatedHeight);
accumulatedHeight += display.Descent;
afterDisplayMaths = true;
if (color != null)
{
display.SetTextColorRecursive(color);
}
displayMathList.Add(display);
break;
void FinalizeInlineDisplay(float ascender, float rawDescender, float lineGap, bool forbidAtLineStart = false)
{
if (color != null)
{
display.SetTextColorRecursive(color);
}
if (line.Width + display.Width > canvasWidth && !forbidAtLineStart)
{
BreakLine(line, displayList, displayMathList);
}
//rawDescender is taken directly from font file and is negative, while IDisplay.Descender is positive
line.Add(display, ascender, -rawDescender, lineGap);
}
case TextAtom.Text t:
var content = UnicodeFontChanger.Instance.ChangeFont(t.Content, style);
var glyphs = GlyphFinder.Instance.FindGlyphs(fonts, content);
//Calling Select(g => g.Typeface).Distinct() speeds up query up to 10 times,
//Calling Max(Func<,>) instead of Select(Func<,>).Max() speeds up query 2 times
var typefaces = glyphs.Select(g => g.Typeface).Distinct().ToList();
Warnings.AssertAll(typefaces,
tf => Typography.OpenFont.Extensions.TypefaceExtensions.RecommendToUseTypoMetricsForLineSpacing(tf),
"This font file is too old. Only font files that support standard typographical metrics are supported.");
display = new TextRunDisplay <Fonts, Glyph>(new Display.Text.AttributedGlyphRun <Fonts, Glyph>(content, glyphs, fonts), t.Range, TypesettingContext.Instance);
FinalizeInlineDisplay(
typefaces.Max(tf => tf.Ascender * tf.CalculateScaleToPixelFromPointSize(fonts.PointSize)),
typefaces.Min(tf => tf.Descender * tf.CalculateScaleToPixelFromPointSize(fonts.PointSize)),
typefaces.Max(tf => tf.LineGap * tf.CalculateScaleToPixelFromPointSize(fonts.PointSize))
);
break;
case TextAtom.Math m:
if (m.DisplayStyle)
{
throw new InvalidCodePathException("Display style maths should have been handled above this switch.");
}
display = Typesetter <Fonts, Glyph> .CreateLine(m.Content, fonts, TypesettingContext.Instance, LineStyle.Text);
var scale = fonts.MathTypeface.CalculateScaleToPixelFromPointSize(fonts.PointSize);
FinalizeInlineDisplay(fonts.MathTypeface.Ascender * scale, fonts.MathTypeface.Descender * scale, fonts.MathTypeface.LineGap * scale);
break;
case TextAtom.ControlSpace cs:
var spaceGlyph = GlyphFinder.Instance.Lookup(fonts, ' ');
display = new TextRunDisplay <Fonts, Glyph>(new Display.Text.AttributedGlyphRun <Fonts, Glyph>(" ", new[] { spaceGlyph }, fonts), cs.Range, TypesettingContext.Instance);
scale = spaceGlyph.Typeface.CalculateScaleToPixelFromPointSize(fonts.PointSize);
FinalizeInlineDisplay(spaceGlyph.Typeface.Ascender * scale, spaceGlyph.Typeface.Descender * scale, spaceGlyph.Typeface.LineGap * scale,
forbidAtLineStart: true); //No spaces at start of line
break;
case TextAtom.Accent a:
var accentGlyph = GlyphFinder.Instance.FindGlyphForCharacterAtIndex(fonts, a.AccentChar.Length - 1, a.AccentChar);
scale = accentGlyph.Typeface.CalculateScaleToPixelFromPointSize(fonts.PointSize);
var accenteeDisplayList = new List <IDisplay <Fonts, Glyph> >();
var invalidDisplayMaths = new List <IDisplay <Fonts, Glyph> >();
var accentDisplayLine = new TextDisplayLineBuilder();
AddDisplaysWithLineBreaks(a.Content, fonts, accentDisplayLine, accenteeDisplayList, invalidDisplayMaths, style, color);
float _ = default;
accentDisplayLine.Clear(0, 0, accenteeDisplayList, ref _, false, false, additionalLineSpacing);
Warnings.Assert(invalidDisplayMaths.Count == 0, "Display maths inside an accentee is unsupported -- ignoring display maths");
var accentee = new Displays(accenteeDisplayList);
var accenteeCodepoint = a.Content.SingleChar(style);
Glyph accenteeSingleGlyph = accenteeCodepoint.HasValue ? GlyphFinder.Instance.Lookup(fonts, accenteeCodepoint.Value) : GlyphFinder.Instance.EmptyGlyph;
var accentDisplay = new AccentDisplay <Fonts, Glyph>(
Typesetter <Fonts, Glyph> .CreateAccentGlyphDisplay(accentee, accenteeSingleGlyph, accentGlyph, TypesettingContext.Instance, fonts, fonts, a.Range),
accentee);
display = accentDisplay;
//accentDisplay.Ascent does not take account of accent glyph's extra height -> accent will be out of bounds if it is on the first line
FinalizeInlineDisplay(Math.Max(accentGlyph.Typeface.Ascender * scale, accentDisplay.Accent.Position.Y + accentDisplay.Ascent), accentGlyph.Typeface.Descender * scale, accentGlyph.Typeface.LineGap * scale);
break;
case TextAtom.Comment _:
break;
case null:
throw new InvalidOperationException("TextAtoms should never be null. You must have sneaked one in.");
case var a:
throw new InvalidCodePathException($"There should not be an unknown type of TextAtom. However, one with type {a.GetType()} was encountered.");
}
}
var relativePositionList = new List <IDisplay <Fonts, Glyph> >();
var absolutePositionList = new List <IDisplay <Fonts, Glyph> >();
var globalLine = new TextDisplayLineBuilder();
AddDisplaysWithLineBreaks(
input,
inputFont,
globalLine,
relativePositionList,
absolutePositionList,
FontStyle.Roman /*FontStyle.Default is FontStyle.Italic, FontStyle.Roman is no change to characters*/,
null
);
BreakLine(globalLine, relativePositionList, absolutePositionList); //remember to finalize the last line
return(new Displays(relativePositionList),
new Displays(absolutePositionList));
}
public Fonts(Fonts cloneMe, float pointSize)
{
PointSize = pointSize;
Typefaces = cloneMe.Typefaces;
MathTypeface = cloneMe.MathTypeface;
}
public static (Displays relative, Displays absolute) Layout(TextAtom input, Fonts inputFont, float canvasWidth)
{
if (input == null)
{
return
(new Displays(Array.Empty <IDisplay <Fonts, Glyph> >()),
new Displays(Array.Empty <IDisplay <Fonts, Glyph> >()));
}
float accumulatedHeight = 0;
TextDisplayLineBuilder line = new TextDisplayLineBuilder();
void BreakLine(List <IDisplay <Fonts, Glyph> > displayList)
{
accumulatedHeight += line.Ascent;
line.Clear(0, -accumulatedHeight, displayList.Add, () => accumulatedHeight += line.Descent);
}
void AddDisplaysWithLineBreaks(TextAtom atom, Fonts fonts,
List <IDisplay <Fonts, Glyph> > displayList,
List <IDisplay <Fonts, Glyph> > displayMathList,
FontStyle style = FontStyle.Roman, /*FontStyle.Default is FontStyle.Italic, FontStyle.Roman is no change to characters*/
Structures.Color?color = null)
{
IDisplay <Fonts, Glyph> display;
switch (atom)
{
case TextAtom.List list:
foreach (var a in list.Content)
{
AddDisplaysWithLineBreaks(a, fonts, displayList, displayMathList, style, color);
}
break;
case TextAtom.Style st:
AddDisplaysWithLineBreaks(st.Content, fonts, displayList, displayMathList, st.FontStyle, color);
break;
case TextAtom.Size sz:
AddDisplaysWithLineBreaks(sz.Content, new Fonts(fonts, sz.PointSize), displayList, displayMathList, style, color);
break;
case TextAtom.Color c:
AddDisplaysWithLineBreaks(c.Content, fonts, displayList, displayMathList, style, c.Colour);
break;
case TextAtom.Space sp:
//Allow space at start of line since user explicitly specified its length
//Also \par generates this kind of spaces
line.AddSpace(sp.Content.ActualLength(MathTable.Instance, fonts));
break;
case TextAtom.Newline n:
BreakLine(displayList);
break;
case TextAtom.Math m when m.DisplayStyle:
BreakLine(displayList);
#warning Replace 12 with a more appropriate spacing
accumulatedHeight += 12;
display = Typesetter <Fonts, Glyph> .CreateLine(m.Content, fonts, TypesettingContext.Instance, LineStyle.Display);
if (color != null)
{
display.SetTextColorRecursive(color);
}
accumulatedHeight += display.Ascent;
display.Position = new System.Drawing.PointF(
IPainterExtensions.GetDisplayPosition(display.Width, display.Ascent, display.Descent, fonts.PointSize, false, canvasWidth, float.NaN, TextAlignment.Top, default, default, default).X,
-accumulatedHeight);
accumulatedHeight += display.Descent;
accumulatedHeight += 12;
if (color != null)
{
display.SetTextColorRecursive(color);
}
displayMathList.Add(display);
break;
void FinalizeInlineDisplay(float ascentMin, bool forbidAtLineStart = false)
{
if (color != null)
{
display.SetTextColorRecursive(color);
}
if (line.Width + display.Width > canvasWidth && !forbidAtLineStart)
{
BreakLine(displayList);
}
line.Add(display, ascentMin);
}
case TextAtom.Text t:
var content = UnicodeFontChanger.Instance.ChangeFont(t.Content, style);
var glyphs = GlyphFinder.Instance.FindGlyphs(fonts, content);
//Calling Select(g => g.Typeface).Distinct() speeds up query up to 10 times,
//Calling Max(Func<,>) instead of Select(Func<,>).Max() speeds up query 2 times
float maxLineSpacing = glyphs.Select(g => g.Typeface).Distinct().Max(tf =>
tf.CalculateRecommendLineSpacing() *
tf.CalculateScaleToPixelFromPointSize(fonts.PointSize)
);
display = new TextRunDisplay <Fonts, Glyph>(Display.Text.AttributedGlyphRuns.Create(content, glyphs, fonts, false), t.Range, TypesettingContext.Instance);
FinalizeInlineDisplay(maxLineSpacing);
break;
case TextAtom.Math m:
if (m.DisplayStyle)
{
throw new InvalidCodePathException("Display style maths should have been handled above this switch.");
}
display = Typesetter <Fonts, Glyph> .CreateLine(m.Content, fonts, TypesettingContext.Instance, Enumerations.LineStyle.Text);
FinalizeInlineDisplay(fonts.MathTypeface.CalculateRecommendLineSpacing() *
fonts.MathTypeface.CalculateScaleToPixelFromPointSize(fonts.PointSize));
break;
case TextAtom.ControlSpace cs:
var spaceGlyph = GlyphFinder.Instance.Lookup(fonts, ' ');
display = new TextRunDisplay <Fonts, Glyph>(Display.Text.AttributedGlyphRuns.Create(" ", new[] { spaceGlyph }, fonts, false), cs.Range, TypesettingContext.Instance);
FinalizeInlineDisplay(spaceGlyph.Typeface.CalculateRecommendLineSpacing() *
spaceGlyph.Typeface.CalculateScaleToPixelFromPointSize(fonts.PointSize),
forbidAtLineStart: true); //No spaces at start of line
break;
case null:
throw new InvalidOperationException("TextAtoms should never be null. You must have sneaked one in.");
case var a:
throw new InvalidCodePathException($"There should not be an unknown type of TextAtom. However, one with type {a.GetType()} was encountered.");
}
}
var relativePositionList = new List <IDisplay <Fonts, Glyph> >();
var absolutePositionList = new List <IDisplay <Fonts, Glyph> >();
AddDisplaysWithLineBreaks(input, inputFont, relativePositionList, absolutePositionList);
BreakLine(relativePositionList); //remember to finalize the last line
return(new Displays(relativePositionList),
new Displays(absolutePositionList));
}
public Fonts(Fonts cloneMe, float pointSize) : base(pointSize)
{
Typefaces = cloneMe.Typefaces;
MathTypeface = cloneMe.MathTypeface;
}
