private void ApplyModifier(GTN Root) {
/*
GIVEN : The node to which to apply the accumulated modifier.
TASK : Make recursive calls to accumulate the modifier sum up the tree,
filling in each individual node's modifier along the way. */
GTN TempChild;
if (Root != null) {
Root.Gx = Root.Gx + ModifierSum;
if (minXCord > Root.Gx) {
minXCord = Root.Gx;
} else if (maxXCord < Root.Gx) {
maxXCord = Root.Gx;
}
ModifierSum = ModifierSum + Root.GModifier;
TempChild = Root.Children;
while (TempChild != null) {
ApplyModifier(TempChild);
TempChild = TempChild.Siblings;
}
ModifierSum = ModifierSum - Root.GModifier;
Root.GModifier = 0.0;
}
}
public void buildGeneralTree(StringTokenizer st, GTN PresentNode, LinkedList llist, draw d)
throws VisualizerLoadException {
String s;
GTN LastChild;
if (st.hasMoreTokens() && numNodes > 0) {
s = st.nextToken();
if (!(s.equals(newTree)) && !(s.equals(EndSnapShot))) {
try {
NextNode = getGTNode(st, s, linespernode, llist, d);
numNodes--;
} catch (EndOfSnapException e) {
Dne = true;
}
LastChild = NextNode;
while (!Dne && (NextNode.Glevel > PresentNode.Glevel)) {
// We must insert NextNode as the LastChild of the PresentNode...*)
if (PresentNode.Children == null) // Special case *)
PresentNode.Children = NextNode;
else LastChild.Siblings = NextNode;
LastChild = NextNode;
buildGeneralTree(st, NextNode, llist, d);
}
} else {
Dne = true;
}
} else Dne = true;
}
public GTN getGTNode(StringTokenizer st, String s, int linesPerNode, LinkedList llist, draw d)
throws EndOfSnapException, VisualizerLoadException {
GTN gtn = new GTN();
if (s.equals("-1")) throw (new EndOfSnapException("End of Snap Shot Reached"));
gtn.Glevel = Format.atoi(s);
gtn.textInNode = getTextNode(st, linesPerNode, llist, d);
return (gtn);
}
double xCoord(GTN Root) {
/*
GIVEN : The pointer to the node whose coordinates we're currently
trying to find.
TASK : Find the xCoord of this node, using the principles used in
Algorithm 3 of "Tidy Drawings of Trees", by Charles Wetherell
and Alfred Shannon. Note that this is a recursive procedure,
which calls on itself at a given level to find the position of
the children at the level below.
RETURN: Ultimately, the xCoord of the Root node of the tree. */
double AccumXCoords, ChildAvgPos, Tempx, Holder8087;
int ChildCount;
GTN TempChild;
if (Root == null) {
return (0.0);
} else {
CurrLevel = CurrLevel + 1;
TempChild = Root.Children;
ChildCount = 0;
AccumXCoords = 0;
while (TempChild != null) {
ChildCount = ChildCount + 1;
Holder8087 = xCoord(TempChild);
AccumXCoords = AccumXCoords + Holder8087;
TempChild = TempChild.Siblings;
}
CurrLevel = CurrLevel - 1;
if (ChildCount == 0) ChildAvgPos = 0.0;
else ChildAvgPos = AccumXCoords / ((double) ChildCount);
if (NextPos[CurrLevel] > ChildAvgPos) Tempx = NextPos[CurrLevel];
else Tempx = ChildAvgPos; // The average of node's children's positions *)
if (Root.Children == null) {
Root.GModifier = 0.0;
Root.Gx = Tempx;
} else {
Modifier[CurrLevel] = Math.max(Modifier[CurrLevel], Tempx - ChildAvgPos);
Root.GModifier = Modifier[CurrLevel];
Root.Gx = Modifier[CurrLevel] + ChildAvgPos;
}
Root.Gy = Starty - (Root.Glevel * (yspacing * Lenx));
NextPos[CurrLevel] = Root.Gx + (xspacing * Lenx);
return (Root.Gx);
}
}