void _setLevelWidth(LayoutNode node, int level) { if (this.MaxLevelWidth[level] < node.W) { this.MaxLevelWidth[level] = node.W; } }
public void CreateNode(string id, object element, double w, double h) { var node = new LayoutNode(this, id, element, w, h); //New node creation... NodeMap[id] = node; Nodes.Add(node); }
LayoutNode _GetLeftmost(LayoutNode node, int level, int maxlevel) { if (level >= maxlevel) { return(node); } if (node._getChildrenCount() == 0) { return(null); } var n = node._getChildrenCount(); for (var i = 0; i < n; i++) { var iChild = node._getChildAt(i); var leftmostDescendant = this._GetLeftmost(iChild, level + 1, maxlevel); if (leftmostDescendant != null) { return(leftmostDescendant); } } return(null); }
void _setLevelHeight(LayoutNode node, int level) { if (this.MaxLevelHeight[level] < node.H) { this.MaxLevelHeight[level] = node.H; } }
public double _getChildrenCenter(TreeLayout tree) { LayoutNode node = this._getFirstChild(); LayoutNode node1 = this._getLastChild(); return(node.Prelim + ((node1.Prelim - node.Prelim) + tree.GetNodeSize(node1)) / 2); }
// public LayoutEdge(TreeLayout tree, LayoutNode source, LayoutNode target, object element) { Tree = tree; Source = source; Target = target; Element = element; }
void _setNeighbors(LayoutNode node, int level) { node.LeftNeighbor = this.PreviousLevelNode[level]; if (node.LeftNeighbor != null) { node.LeftNeighbor.RightNeighbor = node; } this.PreviousLevelNode[level] = node; }
public void _apportion(LayoutNode node, int level) { var firstChild = node._getFirstChild(); var firstChildLeftNeighbor = firstChild.LeftNeighbor; var j = 1; for (var k = Config.iMaxDepth - level; firstChild != null && firstChildLeftNeighbor != null && j <= k;) { double modifierSumRight = 0; double modifierSumLeft = 0; var rightAncestor = firstChild; var leftAncestor = firstChildLeftNeighbor; for (var l = 0; l < j; l++) { rightAncestor = rightAncestor.Parent; leftAncestor = leftAncestor.Parent; modifierSumRight += rightAncestor.Modifier; modifierSumLeft += leftAncestor.Modifier; } var totalGap = (firstChildLeftNeighbor.Prelim + modifierSumLeft + GetNodeSize(firstChildLeftNeighbor) + Config.iSubtreeSeparation) - (firstChild.Prelim + modifierSumRight); if (totalGap > 0) { var subtreeAux = node; var numSubtrees = 0; for (; subtreeAux != null && subtreeAux != leftAncestor; subtreeAux = subtreeAux._getLeftSibling()) { numSubtrees++; } if (subtreeAux != null) { var subtreeMoveAux = node; var singleGap = totalGap / numSubtrees; for (; subtreeMoveAux != leftAncestor; subtreeMoveAux = subtreeMoveAux._getLeftSibling()) { subtreeMoveAux.Prelim += totalGap; subtreeMoveAux.Modifier += totalGap; totalGap -= singleGap; } } } j++; if (firstChild._getChildrenCount() == 0) { firstChild = _GetLeftmost(node, 0, j); } else { firstChild = firstChild._getFirstChild(); } if (firstChild != null) { firstChildLeftNeighbor = firstChild.LeftNeighbor; } } }
//TODO:Delete this one? public void CollapseNode(string nodeid, bool upd) { LayoutNode node = NodeMap[nodeid]; node.Collapsed = !node.Collapsed; if (upd) { UpdateTree(); } }
public void ToggleChildrenVisibility(string nodeid, bool upd) { LayoutNode node = NodeMap[nodeid]; node.ToggleChildren(); if (upd) { UpdateTree(); } }
void _CollapseAllInt(bool flag) { LayoutNode node = null; for (var n = 0; n < this.Nodes.Count; n++) { node = this.Nodes[n]; if (node.CanCollapse) { node.Collapsed = flag; } } this.UpdateTree(); }
public double GetNodeSize(LayoutNode node) { switch (this.Config.iRootOrientation) { case TreeLayout.RO_TOP: case TreeLayout.RO_BOTTOM: return(node.W); case TreeLayout.RO_RIGHT: case TreeLayout.RO_LEFT: return(node.H); } return(0); }
//Layout algorithm public void FirstWalk(LayoutNode node, int level) { LayoutNode leftSibling = null; node.X = 0; node.Y = 0; node.Prelim = 0; node.Modifier = 0; node.LeftNeighbor = null; node.RightNeighbor = null; _setLevelHeight(node, level); _setLevelWidth(node, level); _setNeighbors(node, level); if (node._getChildrenCount() == 0 || level == Config.iMaxDepth) { leftSibling = node._getLeftSibling(); if (leftSibling != null) { node.Prelim = leftSibling.Prelim + GetNodeSize(leftSibling) + Config.iSiblingSeparation; } else { node.Prelim = 0; } } else { var n = node._getChildrenCount(); for (var i = 0; i < n; i++) { var iChild = node._getChildAt(i); FirstWalk(iChild, level + 1); } var midPoint = node._getChildrenCenter(this); midPoint -= GetNodeSize(node) / 2; leftSibling = node._getLeftSibling(); if (leftSibling != null) { node.Prelim = leftSibling.Prelim + GetNodeSize(leftSibling) + Config.iSiblingSeparation; node.Modifier = node.Prelim - midPoint; _apportion(node, level); } else { node.Prelim = midPoint; } } }
public List <LayoutNode> GetSelectedNodes() { LayoutNode node = null; List <LayoutNode> selection = new List <LayoutNode>(); LayoutNode selnode = null; for (var n = 0; n < this.Nodes.Count; n++) { node = this.Nodes[n]; if (node.IsSelected) { selnode = node; selection[selection.Count] = selnode; } } return(selection); }
public void CreateEdge(string srcId, string tgtId, object element) { LayoutNode source = NodeMap[srcId]; if (source.Parent == null) { Root = source; } source.CanCollapse = true; LayoutNode target = NodeMap[tgtId]; target.Parent = source; source.Children.Add(target); LayoutEdge edge = new LayoutEdge(this, source, target, element); source.Edges.Add(edge); Edges.Add(edge); }
public void _secondWalk(TreeLayout tree, LayoutNode node, int level, double X, double Y) { if (level <= tree.Config.iMaxDepth) { var xTmp = tree.RootXOffset + node.Prelim + X; var yTmp = tree.RootYOffset + Y; double maxsizeTmp = 0; double nodesizeTmp = 0; var flag = false; switch (tree.Config.iRootOrientation) { case TreeLayout.RO_TOP: case TreeLayout.RO_BOTTOM: maxsizeTmp = tree.MaxLevelHeight[level]; nodesizeTmp = node.H; break; case TreeLayout.RO_RIGHT: case TreeLayout.RO_LEFT: maxsizeTmp = tree.MaxLevelWidth[level]; flag = true; nodesizeTmp = node.W; break; } switch (tree.Config.iNodeJustification) { case TreeLayout.NJ_TOP: node.X = xTmp; node.Y = yTmp; break; case TreeLayout.NJ_CENTER: node.X = xTmp; node.Y = yTmp + (maxsizeTmp - nodesizeTmp) / 2; break; case TreeLayout.NJ_BOTTOM: node.X = xTmp; node.Y = (yTmp + maxsizeTmp) - nodesizeTmp; break; } if (flag) { var swapTmp = node.X; node.X = node.Y; node.Y = swapTmp; } switch (tree.Config.iRootOrientation) { case TreeLayout.RO_BOTTOM: node.Y = -node.Y - nodesizeTmp; break; case TreeLayout.RO_RIGHT: node.X = -node.X - nodesizeTmp; break; } if (node._getChildrenCount() != 0) { _secondWalk(tree, node._getFirstChild(), level + 1, X + node.Modifier, Y + maxsizeTmp + tree.Config.iLevelSeparation); } var rightSibling = node._getRightSibling(); if (rightSibling != null) { _secondWalk(tree, rightSibling, level, X, Y); } } }