public override Box CreateBox(TexStyle style)
{
// Create box for base atom.
var baseBox = (BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox(style));
if (SubscriptAtom == null && SuperscriptAtom == null)
{
return(baseBox);
}
// Save it shift and use it later
var shift = baseBox.shift;
// Create result box.
var resultBox = HorizontalBox.Get(baseBox);
var subscriptStyle = TexUtility.GetSubscriptStyle(style);
var superscriptStyle = TexUtility.GetSuperscriptStyle(style);
// Set delta value and preliminary shift-up and shift-down amounts depending on type of base atom.
var delta = 0f;
float shiftUp, shiftDown;
if (BaseAtom is AccentedAtom)
{
var accentedBox = ((AccentedAtom)BaseAtom).BaseAtom.CreateBox(TexUtility.GetCrampedStyle(style));
shiftUp = accentedBox.height - TEXConfiguration.main.SupDrop * TexUtility.SizeFactor(superscriptStyle);
shiftDown = accentedBox.depth + TEXConfiguration.main.SubDrop * TexUtility.SizeFactor(subscriptStyle);
}
else if (BaseAtom is CharSymbol)
{
var charFont = ((CharSymbol)BaseAtom).GetChar();
if (!((CharSymbol)BaseAtom).IsTextSymbol)
{
delta = TEXPreference.main.GetCharMetric(charFont, style).advanceDelta;
}
if (delta > TexUtility.FloatPrecision && SubscriptAtom == null)
{
resultBox.Add(StrutBox.Get(delta, 0, 0, 0));
delta = 0;
}
shiftUp = baseBox.height - TEXConfiguration.main.SupDrop * TexUtility.SizeFactor(superscriptStyle);
shiftDown = baseBox.depth + TEXConfiguration.main.SubDrop * TexUtility.SizeFactor(subscriptStyle);
}
else
{
shiftUp = baseBox.height - TEXConfiguration.main.SupDrop * TexUtility.SizeFactor(superscriptStyle);
shiftDown = baseBox.depth + TEXConfiguration.main.SubDrop * TexUtility.SizeFactor(subscriptStyle);
}
Box superscriptBox = null;
Box superscriptContainerBox = null;
Box subscriptBox = null;
Box subscriptContainerBox = null;
if (SuperscriptAtom != null)
{
// Create box for superscript atom.
superscriptBox = SuperscriptAtom.CreateBox(superscriptStyle);
superscriptContainerBox = HorizontalBox.Get(superscriptBox);
// Add box for script space.
superscriptContainerBox.Add(scriptSpaceAtom.CreateBox(style));
// Adjust shift-up amount.
float p;
if (style == TexStyle.Display)
{
p = TEXConfiguration.main.SupMin * TexUtility.SizeFactor(style);
}
else // if (TexUtility.GetCrampedStyle (style) == style)
{
p = TEXConfiguration.main.SupMinNarrow * TexUtility.SizeFactor(style);
}
//else
// p = TEXConfiguration.main.SupMinNarrow * TexUtility.SizeFactor(style);
shiftUp = Mathf.Max(shiftUp, p);
}
if (SubscriptAtom != null)
{
// Create box for subscript atom.
subscriptBox = SubscriptAtom.CreateBox(subscriptStyle);
subscriptContainerBox = HorizontalBox.Get(subscriptBox);
// Add box for script space.
subscriptContainerBox.Add(scriptSpaceAtom.CreateBox(style));
}
// Check if only superscript is set.
if (subscriptBox == null)
{
superscriptContainerBox.shift = -shiftUp;
resultBox.Add(superscriptContainerBox);
resultBox.height = shiftUp + superscriptBox.height;
return(resultBox);
}
// Check if only subscript is set.
if (superscriptBox == null)
{
subscriptBox.shift = Mathf.Max(shiftDown, TEXConfiguration.main.SubMinNoSup * TexUtility.SizeFactor(style));
resultBox.Add(subscriptContainerBox);
resultBox.depth = shiftDown + subscriptBox.depth;
return(resultBox);
}
// Adjust shift-down amount.
shiftDown = Mathf.Max(shiftDown, TEXConfiguration.main.SubMinOnSup * TexUtility.SizeFactor(style));
// Space between subscript and superscript.
float scriptsInterSpace = shiftUp - superscriptBox.depth + shiftDown - subscriptBox.height;
/*if (scriptsInterSpace < 4 * defaultLineThickness)
* {
* shiftUp += 4 * defaultLineThickness - scriptsInterSpace;
*
* // Position bottom of superscript at least 4/5 of X-height above baseline.
* float psi = 0.8f * TexUtility.SizeFactor(style) - (shiftUp - superscriptBox.depth);
* if (psi > 0)
* {
* shiftUp += psi;
* shiftDown -= psi;
* }
* }*/
scriptsInterSpace = shiftUp - superscriptBox.depth + shiftDown - subscriptBox.height;
// If baseAtom is null, make it right-aligned
if (BaseAtom is SpaceAtom && ((SpaceAtom)BaseAtom).policy == StrutPolicy.Misc)
{
var max = Mathf.Max(superscriptContainerBox.width, subscriptContainerBox.width);
if (superscriptContainerBox.width < max)
{
superscriptContainerBox.Add(0, StrutBox.Get(max - superscriptContainerBox.width, 0, 0, 0));
}
if (subscriptContainerBox.width < max)
{
subscriptContainerBox.Add(0, StrutBox.Get(max - subscriptContainerBox.width, 0, 0, 0));
}
}
// Create box containing both superscript and subscript.
var scriptsBox = VerticalBox.Get();
scriptsBox.Add(superscriptContainerBox);
scriptsBox.Add(StrutBox.Get(0, scriptsInterSpace, 0, 0));
scriptsBox.Add(subscriptContainerBox);
scriptsBox.height = shiftUp + superscriptBox.height;
scriptsBox.depth = shiftDown + subscriptBox.depth;
scriptsBox.shift = shift;
resultBox.Add(scriptsBox);
return(resultBox);
}
public override Box CreateBox(TexStyle style)
{
List <List <Box> > boxes = ListPool <List <Box> > .Get();
List <float> boxesHeight = ListPool <float> .Get();
List <float> boxesShift = ListPool <float> .Get();
List <float> boxesWidth = ListPool <float> .Get();
style = TexUtility.GetCrampedStyle(style);
float padding = TEXConfiguration.main.MatrixMargin * TexUtility.SizeFactor(style);
for (int i = 0; i < Elements.Count; i++)
{
boxes.Add(ListPool <Box> .Get());
float h = 0f, d = 0f;
for (int j = 0; j < Elements[i].Count; j++)
{
Box box;
if (Elements[i][j] != null)
{
box = (Elements[i][j].CreateBox(style));
}
else
{
box = (ObjPool <StrutBox> .Get());
}
boxes[i].Add(box);
if (j >= boxesWidth.Count)
{
boxesWidth.Add(box.width);
}
else
{
boxesWidth[j] = Mathf.Max(boxesWidth[j], box.width);
}
h = Mathf.Max(h, box.height);
d = Mathf.Max(d, box.depth);
}
boxesHeight.Add(Mathf.Max(h + d, padding / 2f));
boxesShift.Add(h);
}
bool outsideGap = (horizontalLine > 0 && (enumContains(horizontalLine, 0) || enumContains(horizontalLine, 4))) ||
(verticalLine > 0 && (enumContains(verticalLine, 0) || enumContains(verticalLine, 4)));
Box resultBox = VerticalBox.Get();
Box kern = null;
Box kernHalf = null;
if (boxesWidth.Count > 1 || boxesHeight.Count > 1)
{
kern = StrutBox.Get(padding, padding, 0, 0);
}
if (outsideGap)
{
kernHalf = StrutBox.Get(padding / 2f, padding / 2f, 0, 0);
resultBox.Add(kernHalf);
}
TexAlignment firstRowH = alterH(horizontalAlign % 8);
TexAlignment firstRowV = alterV(verticalAlign % 8);
TexAlignment firstColH = alterH((horizontalAlign >> 3) % 8);
TexAlignment firstColV = alterV((verticalAlign >> 3) % 8);
TexAlignment bodyH = alterH((horizontalAlign >> 6) % 8);
TexAlignment bodyV = alterV((verticalAlign >> 6) % 8);
for (int i = 0; i < Elements.Count; i++)
{
var list = HorizontalBox.Get();
if (outsideGap)
{
list.Add(kernHalf);
}
for (int j = 0; j < Elements[i].Count; j++)
{
if (i == 0)
{
list.Add(VerticalBox.Get(HorizontalBox.Get(boxes[i][j], boxesWidth[j], firstRowH), boxesHeight[i], firstRowV));
}
else if (j == 0)
{
list.Add(VerticalBox.Get(HorizontalBox.Get(boxes[i][j], boxesWidth[j], firstColH), boxesHeight[i], firstColV));
}
else
{
list.Add(VerticalBox.Get(HorizontalBox.Get(boxes[i][j], boxesWidth[j], bodyH), boxesHeight[i], bodyV));
}
//var v = ((VerticalBox)list.children[list.children.Count - 1]);
//v.Shift(-v.height + boxesShift[i]); //Self-Explanatory
if (j < Elements[i].Count - 1)
{
list.Add(kern);
}
else if (outsideGap)
{
list.Add(kernHalf);
}
}
list.depth = boxesHeight[i] - list.height;
resultBox.Add(list);
if (i < Elements.Count - 1)
{
resultBox.Add(kern);
}
else if (outsideGap)
{
resultBox.Add(kernHalf);
}
}
var lineThick = TEXConfiguration.main.LineThickness * TexUtility.SizeFactor(style);
//Add horizontal lines for table
if (horizontalLine > 0)
{
var outside = enumContains(horizontalLine, 0);
var first = enumContains(horizontalLine, 1);
var inset = enumContains(horizontalLine, 2);
var firstThick = enumContains(horizontalLine, 3);
var outsideThick = enumContains(horizontalLine, 4);
float gapX = (padding - lineThick);
float gapXThick = (padding - (lineThick * 2));
float gapXNone = (padding);
float gapOutside = (outside ? (outsideThick ? gapXThick : gapX) : gapXNone);
float gapInset = (inset ? gapX : gapXNone);
float lineOutside = outsideThick ? lineThick * 2 : lineThick;
var insideBox = resultBox;
resultBox = HorizontalBox.Get(resultBox);
if (outsideGap)
{
resultBox.Add(StrutBox.Get(-insideBox.width - lineOutside / 2f, 0, 0, 0));
}
else
{
resultBox.Add(StrutBox.Get(-insideBox.width - lineOutside * 1.5f, 0, 0, 0));
}
for (int i = 0; i < boxesWidth.Count; i++)
{
if (i == 0)
{
if (outside)
{
resultBox.Add(HorizontalRule.Get(insideBox.height, lineOutside, 0, insideBox.depth));
}
resultBox.Add(StrutBox.Get(boxesWidth[i] + gapOutside, 0, 0, 0));
continue;
}
if (i == 1)
{
if (first)
{
resultBox.Add(HorizontalRule.Get(insideBox.height, firstThick ? lineThick * 2 : lineThick, 0, insideBox.depth));
}
resultBox.Add(StrutBox.Get(boxesWidth[i] + (first ? (firstThick ? gapXThick : gapX) : gapXNone), 0, 0, 0));
continue;
}
if (inset)
{
resultBox.Add(HorizontalRule.Get(insideBox.height, lineThick, 0, insideBox.depth));
}
resultBox.Add(StrutBox.Get(boxesWidth[i] + gapInset, 0, 0, 0));
}
if (outside)
{
resultBox.Add(HorizontalRule.Get(insideBox.height, lineOutside, 0, insideBox.depth));
}
}
if (verticalLine > 0)
{
var outside = enumContains(verticalLine, 0);
var first = enumContains(verticalLine, 1);
var inset = enumContains(verticalLine, 2);
var firstThick = enumContains(verticalLine, 3);
var outsideThick = enumContains(verticalLine, 4);
float gapX = (padding - lineThick);
float gapXThick = (padding - (lineThick * 2));
float gapXNone = (padding);
float gapOutside = (outside ? (outsideThick ? gapXThick : gapX) : gapXNone);
float gapInset = (inset ? gapX : gapXNone);
float lineOutside = outsideThick ? lineThick * 2 : lineThick;
var insideBox = resultBox;
var size = insideBox.width;
resultBox = VerticalBox.Get(resultBox);
if (outsideGap)
{
resultBox.Add(StrutBox.Get(0, -insideBox.totalHeight - lineOutside / 2f, 0, 0));
}
else
{
resultBox.Add(StrutBox.Get(0, -insideBox.totalHeight, 0, 0));
}
for (int i = 0; i < boxesHeight.Count; i++)
{
if (i == 0)
{
if (outside)
{
resultBox.Add(HorizontalRule.Get(lineOutside, size, 0));
}
resultBox.Add(StrutBox.Get(0, boxesHeight[i] + (outsideGap ? gapOutside : gapOutside / 2f), 0, 0));
}
else if (i == 1)
{
if (first)
{
resultBox.Add(HorizontalRule.Get(firstThick ? lineThick * 2 : lineThick, size, 0));
}
var thick = (first ? (firstThick ? gapXThick : gapX) : gapXNone);
resultBox.Add(StrutBox.Get(0, boxesHeight[i] + (boxesHeight.Count == 2 && !outsideGap ? thick / 2f : thick), 0, 0));
}
else
{
if (inset)
{
resultBox.Add(HorizontalRule.Get(lineThick, size, 0));
}
resultBox.Add(StrutBox.Get(0, boxesHeight[i] + (i < boxesHeight.Count - 1 || outsideGap ? gapInset : gapInset / 2f), 0, 0));
}
}
if (outside && outsideGap)
{
resultBox.Add(HorizontalRule.Get(lineOutside, size, 0, 0));
}
}
TexUtility.CentreBox(resultBox, style);
//Clear resources
ListPool <float> .Release(boxesHeight);
ListPool <float> .Release(boxesWidth);
ListPool <float> .Release(boxesShift);
for (int i = 0; i < boxes.Count; i++)
{
ListPool <Box> .ReleaseNoFlush(boxes[i]);
}
ListPool <List <Box> > .ReleaseNoFlush(boxes);
return(resultBox);
}
