/// <summary>
/// Creates a new sub-/superscript object.
/// </summary>
/// <param name="type">The type.</param>
public void CreateSubAndSuperscript(CharType type)
{
if (SubAndSuperscriptExpr != null && (SubAndSuperscriptType == type || (type == CharType.Subscript && SubAndSuperscriptExpr.SubScript == null) || (type == CharType.Superscript && SubAndSuperscriptExpr.SuperScript == null)))
{
// Append the expression.
}
else
{
if (SubAndSuperscriptExpr != null)
{
CurrentExpr = null;
}
var script = new SubAndSuperscript();
script.Expression = CurrentExpr;
SubAndSuperscriptExpr = script;
CurrentExpr = script;
// Update the result.
if (Result == null || !(Result is Block))
{
Result = CurrentExpr;
}
else
{
var block = (Block)Result;
block.Expressions[block.Expressions.Count - 1] = CurrentExpr;
}
}
SubAndSuperscriptType = type;
}
/// <summary>
/// Set the new expression.
/// </summary>
/// <param name="newExpr">The new expression.</param>
public void SwitchCurrentExpression(ExpressionBase newExpr)
{
var updateResult = true;
// Whitespace insertion control at operators.
if (newExpr is Operator)
{
var op = (Operator)newExpr;
// TODO @ Parser: Still errors in whitespace insertion...
if (CurrentExpr == null || (CurrentExpr is Operator && ((Operator)CurrentExpr).HasRightWhitespace))
{
op.HasLeftWhitespace = false;
op.HasRightWhitespace = false;
}
}
// Control the behaviour of sub- and superscript.
if (SubAndSuperscriptExpr != null)
{
if (SubAndSuperscriptType == CharType.Subscript)
{
if (SubAndSuperscriptExpr.SubScript == null)
{
SubAndSuperscriptExpr.SubScript = newExpr;
return;
}
else
{
SubAndSuperscriptExpr = null;
SubAndSuperscriptType = CharType.Unknown;
}
}
else
{
if (SubAndSuperscriptExpr.SuperScript == null)
{
SubAndSuperscriptExpr.SuperScript = newExpr;
return;
}
else
{
SubAndSuperscriptExpr = null;
SubAndSuperscriptType = CharType.Unknown;
}
}
}
// Assign new expression to current expression.
CurrentExpr = newExpr;
// Handle command expressions. Stop adding expressions after the required count was reached.
if (CommandExpr != null)
{
updateResult = false;
CommandExpr.AddEpression(CurrentExpr);
CurrentExpr = CommandExpr;
if (CommandExpr.RequiredExpressionCount == 0)
{
// Handle fractions before they are finished.
if (CommandExpr is Fraction)
{
FractionStackCounter--;
}
// Set the previous command expression or null.
if (CommandExprStack.Count > 0)
{
CommandExpr = CommandExprStack.Pop();
}
else
{
CommandExpr = null;
}
}
}
// Check, whether this expression is a composite expression and therefore needs input blocks.
if (CurrentExpr is CompositeExpression && (CurrentExpr != CommandExpr) && ((CompositeExpression)CurrentExpr).RequiredExpressionCount > 0)
{
if (CommandExpr != null)
{
CommandExprStack.Push(CommandExpr);
}
CommandExpr = (CompositeExpression)CurrentExpr;
// Handle the fraction stack.
if (newExpr is Fraction)
{
FractionStackCounter++;
((Fraction)newExpr).IsSubFraction = FractionStackCounter > 1;
}
}
// Break here, if needed.
if (updateResult)
{
// Set the new result:
// - If the last result was null, copy the new expression.
// - Otherwise, try to cast to a block or create a new one.
if (Result == null)
{
Result = CurrentExpr;
}
else
{
var block = (Result is Block) ? (Block)Result : new Block()
{
Expressions = { Result }
};
block.Expressions.Add(CurrentExpr);
Result = block;
}
}
}
