public Box GenerateDelimiterBox(HorizontalBox result, ref int elementPos, ref int resultPos)
{
var curAtom = Elements[elementPos];
if (!(curAtom is CharSymbol) || !((CharSymbol)curAtom).IsDelimiter)
{
// This is not delimiter, hence just create and do nothing.
var box = curAtom.CreateBox();
if (curAtom.Type == CharType.BigOperator) // specific patch to BigOperator
{
TexUtility.CentreBox(box);
}
if (box is HorizontalBox && (curAtom is AttrSizeAtom || curAtom is AttrStyleAtom)) // specific patch to Atoms that should be wrappable.
{
var h = box as HorizontalBox;
result.AddRange(h, resultPos);
resultPos += h.children.Count;
}
else
{
result.Add(resultPos++, box);
}
lastGeneratedBox = box;
return(box);
}
var nextAtom = elementPos + 1 < Elements.Count ? Elements[elementPos + 1] : null;
var prevAtom = elementPos > 0 ? Elements[elementPos - 1] : null;
var minHeight = 0f;
var ourPos = resultPos;
if (nextAtom != null && curAtom.RightType == CharType.OpenDelimiter)
{
elementPos++;
var nextBox = GenerateDelimiterBox(result, ref elementPos, ref resultPos);
minHeight = nextBox.totalHeight;
}
else if (lastGeneratedBox != null && curAtom.LeftType == CharType.CloseDelimiter)
{
var prevBox = lastGeneratedBox;
minHeight = prevBox.totalHeight;
}
else
{
if (prevAtom != null && lastGeneratedBox != null)
{
var prevBox = lastGeneratedBox;
minHeight = prevBox.totalHeight;
}
if (nextAtom != null)
{
elementPos++;
var nextBox = GenerateDelimiterBox(result, ref elementPos, ref resultPos);
minHeight = Mathf.Max(nextBox.totalHeight, minHeight);
}
}
var curBox = curAtom is SymbolAtom ? (((SymbolAtom)curAtom).CreateBox(minHeight)) : curAtom.CreateBox();
TexUtility.CentreBox(curBox);
result.Add(ourPos, curBox);
if (ourPos == resultPos)
{
lastGeneratedBox = curBox;
}
resultPos++;
return(curBox);
}
public Box GenerateDelimiterBox(HorizontalBox result, ref int elementPos, ref int resultPos, TexStyle style)
{
var curAtom = Elements[elementPos];
if (!(curAtom is CharSymbol) || !((CharSymbol)curAtom).IsDelimiter)
{
// This is not delimiter, hence just create and do nothing.
var box = curAtom.CreateBox(style);
if (curAtom.Type == CharType.BigOperator)
{
TexUtility.CentreBox(box, style);
}
result.Add(resultPos, box);
lastGeneratedBox = box;
resultPos++;
return(box);
}
var nextAtom = elementPos + 1 < Elements.Count ? Elements[elementPos + 1] : null;
var prevAtom = elementPos > 0 ? Elements[elementPos - 1] : null;
var minHeight = 0f;
var ourPos = resultPos;
if (nextAtom != null && curAtom.GetRightType() == CharType.OpenDelimiter)
{
elementPos++;
var nextBox = GenerateDelimiterBox(result, ref elementPos, ref resultPos, style);
minHeight = nextBox.totalHeight;
}
else if (lastGeneratedBox != null && curAtom.GetLeftType() == CharType.CloseDelimiter)
{
var prevBox = lastGeneratedBox;
minHeight = prevBox.totalHeight;
}
else
{
if (prevAtom != null && lastGeneratedBox != null)
{
var prevBox = lastGeneratedBox;
minHeight = prevBox.totalHeight;
}
if (nextAtom != null)
{
elementPos++;
var nextBox = GenerateDelimiterBox(result, ref elementPos, ref resultPos, style);
minHeight = Mathf.Max(nextBox.totalHeight, minHeight);
}
}
var curBox = curAtom is SymbolAtom ? (((SymbolAtom)curAtom).CreateBox(style, minHeight)) : curAtom.CreateBox(style);
TexUtility.CentreBox(curBox, style);
result.Add(ourPos, curBox);
if (ourPos == resultPos)
{
lastGeneratedBox = curBox;
}
resultPos++;
return(curBox);
}
public override Box CreateBox()
{
// Create box for base atom.
// Save it shift and use it later
// Create result box.
// Set delta value and preliminary shift-up and shift-down amounts depending on type of base atom.
float shiftUp = 0, shiftDown = 0;
Box baseBox; HorizontalBox resultBox;
if (SubscriptAtom == null && SuperscriptAtom == null)
{
return(BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox());
}
if (BaseAtom is AccentedAtom)
{
TexContext.Environment.Push(TexUtility.GetCrampedStyle());
baseBox = ((AccentedAtom)BaseAtom).BaseAtom.CreateBox();
TexContext.Environment.Pop();
}
else
{
baseBox = (BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox());
//if (BaseAtom is CharSymbol)
//{
// var delta = 0f;
// var ch = ((CharSymbol)BaseAtom).GetChar();
// if (!((CharSymbol)BaseAtom).IsTextSymbol)
// delta = ch.italix + bearing - width;
// if (delta > TexUtility.FloatPrecision && SubscriptAtom == null)
// {
// resultBox.Add(StrutBox.Get(delta, 0, 0, 0));
// delta = 0;
// }
//}
}
resultBox = HorizontalBox.Get(baseBox);
var shift = baseBox.shift;
Box superscriptBox = null;
HorizontalBox superscriptContainerBox = null;
Box subscriptBox = null;
HorizontalBox subscriptContainerBox = null;
TexContext.Environment.Push(TexUtility.GetSuperscriptStyle());
shiftUp = baseBox.height - TEXConfiguration.main.SupDrop * TexContext.Scale;
if (SuperscriptAtom != null)
{
// Create box for superscript atom.
superscriptBox = SuperscriptAtom.CreateBox();
superscriptContainerBox = HorizontalBox.Get(superscriptBox);
// Add box for script space.
superscriptContainerBox.Add(scriptSpaceAtom.CreateBox());
// Adjust shift-up amount.
float p;
if (TexContext.Environment.value == TexEnvironment.Display)
{
p = TEXConfiguration.main.SupMin * TexContext.Scale;
}
else
{
p = TEXConfiguration.main.SupMinNarrow * TexContext.Scale;
}
shiftUp = Mathf.Max(shiftUp, p);
}
TexContext.Environment.Pop();
TexContext.Environment.Push(TexUtility.GetSubscriptStyle());
shiftDown = baseBox.depth + TEXConfiguration.main.SubDrop * TexContext.Scale;
if (SubscriptAtom != null)
{
// Create box for subscript atom.
subscriptBox = SubscriptAtom.CreateBox();
subscriptContainerBox = HorizontalBox.Get(subscriptBox);
// Add box for script space.
subscriptContainerBox.Add(scriptSpaceAtom.CreateBox());
}
TexContext.Environment.Pop();
// 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 * TexContext.Scale);
resultBox.Add(subscriptContainerBox);
resultBox.depth = shiftDown + subscriptBox.depth;
return(resultBox);
}
// Adjust shift-down amount.
shiftDown = Mathf.Max(shiftDown, TEXConfiguration.main.SubMinOnSup * TexContext.Scale);
// Space between subscript and superscript.
float scriptsInterSpace = shiftUp - superscriptBox.depth + shiftDown - subscriptBox.height;
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);
}