@Override
public void recoverObjectProperties() {
// This method has to override abstract class
// if any one of it's children answer true to wasLayedOut
// then we assume that this diagram had entities defined and
// was already layed out at one time.
// This should be called after the initial layout method only!!!
List children = getChildren();
Iterator iter = children.iterator();
DiagramModelNode nextChild = null;
while (iter.hasNext()) {
nextChild = (DiagramModelNode) iter.next();
if (nextChild.wasLayedOut()) nextChild.recoverObjectProperties();
}
}
@Override
public boolean wasLayedOut() {
// This method has to override abstract class
// if any one of it's children answer true to same method
// then we assume that this diagram had entities defined and
// was already layed out at one time.
List children = getChildren();
Iterator iter = children.iterator();
DiagramModelNode nextChild = null;
while (iter.hasNext()) {
nextChild = (DiagramModelNode) iter.next();
if (nextChild.wasLayedOut()) return true;
}
return false;
}
/*
* (non-Javadoc)
* @see com.metamatrix.modeler.diagram.ui.model.DiagramModelNode#addChildren(java.util.List)
*/
@Override
public void addChildren(List newChildren) {
if (newChildren != null && !newChildren.isEmpty()) {
Object nextChild;
Iterator iter = newChildren.iterator();
while (iter.hasNext()) {
nextChild = iter.next();
((DiagramModelNode) nextChild).setParent(this);
}
super.addChildren(newChildren);
}
}
@Override
protected int run() {
if (this.getComponentCount() == 0) return SUCCESSFUL;
int i = buildTree();
if (i != 0) return i;
TreeNode treenode = (TreeNode) _compToNode.get(modelRoot);
if (treenode == null) return ERROR_ROOT_NOT_MANAGED;
TreeNode[] treenodes = new TreeNode[_depth + 1];
treenode.setNeighbors(treenodes);
double d = 0.0;
double d_85_ = 0.0;
double d_86_ = 0.0;
double d_87_ = 1.0;
double d_88_ = 0.0;
double[] ds = new double[_depth + 1];
if (_method == 0) {
double[] ds_89_ = new double[_depth + 1];
double[] ds_90_ = new double[_depth + 1];
treenode.calculatePosition(ds_89_, ds_90_);
treenode.setEven();
for (int i_91_ = 0; i_91_ <= _depth; i_91_++) d_86_ = Math.max(d_86_, ds_90_[i_91_]);
if (_useObjectsSizes) {
treenode.getMaximumWidths(ds);
for (int i_92_ = 0; i_92_ <= _depth; i_92_++) {
d_88_ = ds[i_92_];
ds[i_92_] += d - 0.5 * d_88_;
d += d_88_;
d_85_ = Math.max(d_85_, ds_89_[i_92_]);
}
}
} else {
double[] ds_93_ = new double[1];
double[] ds_94_ = new double[1];
treenode.calculateSeparatePosition(ds_93_, ds_94_);
d_86_ = ds_94_[0];
if (_useObjectsSizes) {
treenode.getMaximumWidths(ds);
for (int i_95_ = 0; i_95_ <= _depth; i_95_++) {
d_88_ = ds[i_95_];
ds[i_95_] += d - 0.5 * d_88_;
d += d_88_;
}
d_85_ = ds_93_[0];
}
}
double d_96_ = 0.0;
double d_97_ = 0.0;
double d_98_ = this.getWidth();
double d_99_ = this.getHeight();
double d_100_ = this.getXOrigin();
double d_101_ = this.getYOrigin();
if (_useObjectsSizes) {
d_96_ = 1.0;
d_97_ = 1.0;
}
if (_orientation == ORIENTATION_ROOT_TOP || _orientation == ORIENTATION_ROOT_BOTTOM) {
d_88_ = d_98_;
d_98_ = d_99_;
d_99_ = d_88_;
d_88_ = d_100_;
d_100_ = d_101_;
d_101_ = d_88_;
}
if (_orientation == ORIENTATION_ROOT_RIGHT || _orientation == ORIENTATION_ROOT_BOTTOM) {
d_100_ += d_98_;
d_101_ += d_99_;
d_96_ = -d_96_;
d_97_ = -d_97_;
d_87_ = -1.0;
}
if (_fixedSpacing) {
if (_orientation == ORIENTATION_ROOT_TOP || _orientation == ORIENTATION_ROOT_BOTTOM) {
d_98_ = d_87_ * _fixedYSpacing;
d_99_ = d_87_ * _fixedXSpacing;
} else {
d_98_ = d_87_ * _fixedXSpacing;
d_99_ = d_87_ * _fixedYSpacing;
}
} else {
d_98_ = d_87_ * (d_98_ - d) / (_depth + 1);
d_99_ = d_87_ * (d_99_ - d_85_) / d_86_;
}
d_100_ += 0.5 * d_98_;
d_101_ -= 0.5 * d_99_;
for (int i_102_ = 0; i_102_ <= _depth; i_102_++)
ds[i_102_] = d_100_ + d_96_ * ds[i_102_] + d_98_ * i_102_;
DiagramModelNode[] modelNodes = getNodeArray();
int i_103_ = modelNodes.length;
if (_orientation == ORIENTATION_ROOT_RIGHT || _orientation == ORIENTATION_ROOT_LEFT) {
for (int i_104_ = 0; i_104_ < i_103_; i_104_++) {
DiagramModelNode modelNode = modelNodes[i_104_];
treenode = rawTreeNodes[i_104_];
if (treenode._level != -1) {
int newX = (int) ds[treenode._level];
int newY =
(int)
(treenode._absolutePosition * d_97_
+ treenode._relativePosition * d_99_
+ d_101_);
modelNode.setCenterXY(newX, newY);
}
}
} else {
for (int i_105_ = 0; i_105_ < i_103_; i_105_++) {
DiagramModelNode modelNode = modelNodes[i_105_];
treenode = rawTreeNodes[i_105_];
if (treenode._level != -1) {
int newX = (int) ds[treenode._level];
int newY =
(int)
(treenode._absolutePosition * d_97_
+ treenode._relativePosition * d_99_
+ d_101_);
modelNode.setCenterXY(newX, newY);
}
}
}
// if (this.getPropagate())
// this.propagate();
return SUCCESSFUL;
}
private int buildTree() {
_compToNode.clear();
int i = this.getComponentCount();
if (i == 0) return 0;
DiagramModelNode[] modelNodes = getNodeArray();
rawTreeNodes = new TreeNode[i];
for (int iiNode = 0; iiNode < i; iiNode++) {
DiagramModelNode modelNode = modelNodes[iiNode];
rawTreeNodes[iiNode] = new TreeNode(modelNode);
_compToNode.put(modelNode, rawTreeNodes[iiNode]);
}
if (_order == LIST_ORDER) {
for (int i_107_ = 0; i_107_ < i; i_107_++) rawTreeNodes[i_107_]._orderVar = i_107_;
} else if (_orientation == ORIENTATION_ROOT_LEFT) {
for (int i_108_ = 0; i_108_ < i; i_108_++)
rawTreeNodes[i_108_]._orderVar = modelNodes[i_108_].getCenterY();
} else if (_orientation == ORIENTATION_ROOT_TOP) {
for (int i_109_ = 0; i_109_ < i; i_109_++)
rawTreeNodes[i_109_]._orderVar = modelNodes[i_109_].getCenterX();
} else if (_orientation == ORIENTATION_ROOT_RIGHT) {
for (int i_110_ = 0; i_110_ < i; i_110_++)
rawTreeNodes[i_110_]._orderVar = -modelNodes[i_110_].getCenterY();
} else {
for (int i_111_ = 0; i_111_ < i; i_111_++)
rawTreeNodes[i_111_]._orderVar = -modelNodes[i_111_].getCenterX();
}
if (_orientation == ORIENTATION_ROOT_LEFT || _orientation == ORIENTATION_ROOT_RIGHT) {
for (int i_112_ = 0; i_112_ < i; i_112_++) {
rawTreeNodes[i_112_]._width = modelNodes[i_112_].getWidth();
rawTreeNodes[i_112_]._height = modelNodes[i_112_].getHeight();
}
} else {
for (int i_113_ = 0; i_113_ < i; i_113_++) {
rawTreeNodes[i_113_]._width = modelNodes[i_113_].getHeight();
rawTreeNodes[i_113_]._height = modelNodes[i_113_].getWidth();
}
}
for (int iiNode = 0; iiNode < i; iiNode++) {
DiagramModelNode sourceNode = modelNodes[iiNode];
Vector sourceConnections = sourceNode.getSourceConnections();
TreeNode sourceTreeNode = (TreeNode) _compToNode.get(sourceNode);
if (!sourceConnections.isEmpty()) {
Iterator iter = sourceConnections.iterator();
NodeConnectionModel nextConnection = null;
while (iter.hasNext()) {
nextConnection = (NodeConnectionModel) iter.next();
TreeNode targetTreeNode = (TreeNode) _compToNode.get(nextConnection.getTargetNode());
if (sourceTreeNode != null && targetTreeNode != null) {
sourceTreeNode.addLinkToNode(targetTreeNode);
targetTreeNode.addLinkToNode(sourceTreeNode);
}
}
}
}
if (modelRoot == null) return ERROR_TREE_HAS_NO_ROOT;
TreeNode treenode = (TreeNode) _compToNode.get(modelRoot);
if (treenode == null) return ERROR_ROOT_NOT_MANAGED;
_depth = -1;
try {
_depth = treenode.setParent(null);
} catch (NotATreeException notatreeexception) {
return ERROR_NOT_A_TREE;
}
return SUCCESSFUL;
}
/*
* (non-Javadoc)
* @see com.metamatrix.modeler.diagram.ui.model.DiagramModelNode#addChild(com.metamatrix.modeler.diagram.ui.model.DiagramModelNode)
*/
@Override
public void addChild(DiagramModelNode child) {
child.setParent(this);
super.addChild(child);
}