// Attach nested region to the child.
// **Need to be careful to set attributes correctly here.
public ParseState AddNestedRegion(RelationTreeNode relationNode, SymbolTreeNode snode)
{
// Create new child node. *Maintain previous node (depth-first
// parse).
ParseState newState = new ParseState();
// Attributes..
newState.rootNode = relationNode;
newState.numberStrokes = relationNode.lbt.strokes.Count; // Only need to consume strokes in this sub-region.
newState.completesParse = false; // This branch cannot be the final NT for a rule.
// Wipe out candidate and previous symbols.
newState.candidateSymbols = null;
newState.previous = new PreviousSymbol();
newState.previous.symbol = new LexerResult();
newState.previous.regionsOptional = true;
/*if (relationNode.lbt.strokes == null)
* Console.WriteLine("RELATION NODE LBT: NULL!!");
* else
* Console.WriteLine("RELATION NODE LBT: {0} strokes", relationNode.lbt.strokes.Count);
*/
newState.previous.symbol.lbt = relationNode.lbt;
// COMPLETING PARSE?
//newState.completesParse = previous.parent.
// Attach region to parent node.
previous.parent.children.Add(relationNode);
return(newState);
}
public ParseState(ParseState pstate, RelationTreeNode node)
{
candidateSymbols = pstate.candidateSymbols;
numberStrokes = pstate.numberStrokes;
completesParse = pstate.completesParse;
previous = pstate.previous;
// Inherit all attributes, but modify the root node.
rootNode = node;
}
public PartitionResult()
{
ABOVE = new RelationTreeNode("ABOVE", "_partition");
BELOW = new RelationTreeNode("BELOW", "_partition");
CONTAINS = new RelationTreeNode("CONTAINS", "_partition");
SUPER = new RelationTreeNode("SUPER", "_partition");
SUBSC = new RelationTreeNode("SUBSC", "_partition");
// Additions.
TLEFT = new RelationTreeNode("TLEFT", "_partition");
BLEFT = new RelationTreeNode("BLEFT", "_partition");
}
public override ParseTreeNode clone()
{
// Node labels and stoke data will be fixed for a given node (ref. only), but children will
// differ for different parse trees (new copy).
RelationTreeNode nodeCopy = new RelationTreeNode(relationType, nodeType);
nodeCopy.strokes = strokes;
nodeCopy.lbt = null;
if (lbt != null)
{
nodeCopy.lbt = new LBT(lbt); // copy lbt
}
foreach (ParseTreeNode child in children)
{
nodeCopy.children.Add(child.clone());
}
return(nodeCopy);
}
// include generated mathml from right nodes to siblings to their left (because of mrow)
virtual public string ChildMathML(string right)
{
if (this is RelationTreeNode || this is SymbolTreeNode)
{
throw new Exception("Child classes must re-implement this method");
}
if (this.children.Count > 0 && (this.children[0] is RelationTreeNode || this.children[0] is SymbolTreeNode))
{
string this_symbol = null;
if (this.children.Count == 2)
{
// one relation
string relationship = (this.children[1] as RelationTreeNode).relationType;
switch (relationship)
{
// sqrt
case "CONTAINS":
this_symbol = String.Format("<msqrt>{0}</msqrt>", this.children[1].ChildMathML(null));
break;
// supersscript
case "SUPER":
this_symbol = String.Format("<msup>{0}{1}</msup>", this.children[0].ChildMathML(null), this.children[1].ChildMathML(null));
break;
// subscript
case "SUBSC":
this_symbol = String.Format("<msub>{0}{1}</msub>", this.children[0].ChildMathML(null), this.children[1].ChildMathML(null));
break;
}
}
else if (this.children.Count == 3)
{
// frac/sum/etc.
string above = null, below = null, this_sym = null;
bool is_frac = false;
foreach (ParseTreeNode ptn in this.children)
{
if (ptn is RelationTreeNode)
{
RelationTreeNode rtn = null;
rtn = ptn as RelationTreeNode;
if (rtn.relationType == "ABOVE")
{
above = rtn.ChildMathML(null);
}
if (rtn.relationType == "BELOW")
{
below = rtn.ChildMathML(null);
}
}
else if (ptn is SymbolTreeNode)
{
SymbolTreeNode stn = ptn as SymbolTreeNode;
this_sym = stn.ChildMathML(null);
if (stn.nodeType.Equals("-"))
{
is_frac = true;
}
}
}
if (is_frac)
{
this_symbol = String.Format("<mfrac>{0}{1}</mfrac>", above, below);
}
else
{
this_symbol = String.Format("<msubsup>{0}{1}{2}</msubsup>", this_sym, below, above);
}
}
else
{
for (int k = this.children.Count - 1; k >= 0; k--)
{
right = this.children[k].ChildMathML(right);
}
}
if (right == null)
{
return(this_symbol);
}
if (this_symbol == null)
{
return(right);
}
// something to our right
return(String.Format("<mrow>{0}{1}</mrow>", this_symbol, right));
}
else
{
for (int k = this.children.Count - 1; k >= 0; k--)
{
right = this.children[k].ChildMathML(right);
}
return(right);
}
}
public ParseState RemoveNestedRegion(RelationTreeNode relationNode)
{
previous.parent.children.Remove(relationNode);
return(this);
}
