protected void doSort() {
Pair<ElementNode, List<ElementNode>> pair = storeSelection();
Enumeration<ParentNode> children = getRootNodeChildren();
while (children.hasMoreElements()) {
ParentNode classNode = children.nextElement();
sortNode(classNode, myComparator);
myTreeModel.nodeStructureChanged(classNode);
}
restoreSelection(pair);
}
protected void restoreTree() {
Pair<ElementNode, List<ElementNode>> selection = storeSelection();
DefaultMutableTreeNode root = getRootNode();
if (!myShowClasses || myContainerNodes.isEmpty()) {
List<ParentNode> otherObjects = new ArrayList<ParentNode>();
Enumeration<ParentNode> children = getRootNodeChildren();
ParentNode newRoot =
new ParentNode(
null, new MemberChooserObjectBase(getAllContainersNodeName()), new Ref<Integer>(0));
while (children.hasMoreElements()) {
final ParentNode nextElement = children.nextElement();
if (nextElement instanceof ContainerNode) {
final ContainerNode containerNode = (ContainerNode) nextElement;
Enumeration<MemberNode> memberNodes = containerNode.children();
List<MemberNode> memberNodesList = new ArrayList<MemberNode>();
while (memberNodes.hasMoreElements()) {
memberNodesList.add(memberNodes.nextElement());
}
for (MemberNode memberNode : memberNodesList) {
newRoot.add(memberNode);
}
} else {
otherObjects.add(nextElement);
}
}
replaceChildren(root, otherObjects);
sortNode(newRoot, myComparator);
if (newRoot.children().hasMoreElements()) root.add(newRoot);
} else {
Enumeration<ParentNode> children = getRootNodeChildren();
while (children.hasMoreElements()) {
ParentNode allClassesNode = children.nextElement();
Enumeration<MemberNode> memberNodes = allClassesNode.children();
ArrayList<MemberNode> arrayList = new ArrayList<MemberNode>();
while (memberNodes.hasMoreElements()) {
arrayList.add(memberNodes.nextElement());
}
Collections.sort(arrayList, myComparator);
for (MemberNode memberNode : arrayList) {
myNodeToParentMap.get(memberNode).add(memberNode);
}
}
replaceChildren(root, myContainerNodes);
}
myTreeModel.nodeStructureChanged(root);
defaultExpandTree();
restoreSelection(selection);
}
/** Adds a new group to our tree and element model. */
final void addNewGroup() {
DefaultTreeModel model = (DefaultTreeModel) this.tree.getModel();
boolean groupSummaryVisibleByDefault = UIManager.getBoolean(GROUP_SUMMARY_VISIBLE_DEFAULT);
boolean scopeVisibleByDefault = UIManager.getBoolean(ANALOG_SCOPE_VISIBLE_DEFAULT);
int groupCount = this.model.getGroups().size();
String name = String.format("Group %d", Integer.valueOf(groupCount + 1));
// Create model structure...
ElementGroup newGroup = this.model.addGroup(name);
newGroup.setVisible(true);
SignalElement groupSummaryElement = SignalElement.createGroupSummaryElement(newGroup);
groupSummaryElement.setEnabled(groupSummaryVisibleByDefault);
newGroup.addElement(groupSummaryElement);
SignalElement analogScopeElement = SignalElement.createAnalogScopeElement(newGroup);
analogScopeElement.setEnabled(scopeVisibleByDefault);
newGroup.addElement(analogScopeElement);
// Create tree structure...
ElementTreeNode rootNode = (ElementTreeNode) model.getRoot();
ElementTreeNode groupNode = new ElementTreeNode(newGroup);
rootNode.add(groupNode);
groupNode.add(new ElementTreeNode(groupSummaryElement));
groupNode.add(new ElementTreeNode(analogScopeElement));
int index = rootNode.getIndex(groupNode);
model.nodesWereInserted(rootNode, new int[] {index});
model.nodeStructureChanged(groupNode);
this.tree.expandRow(index);
}
/* Clear all existing nodes from the tree model and rebuild from scratch.
*/
protected void refreshTree() {
DefaultMutableTreeNode propertiesNode;
DefaultMutableTreeNode leaf;
// First clear the existing tree by simply enumerating
// over the root node's children and removing them one by one.
while (treeModel.getChildCount(rootNode) > 0) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode) treeModel.getChild(rootNode, 0);
treeModel.removeNodeFromParent(child);
child.removeAllChildren();
child.removeFromParent();
}
treeModel.nodeStructureChanged(rootNode);
treeModel.reload();
tScrollPane.repaint();
// Now rebuild the tree below its root
try {
// Start by naming the root node from its URL:
rootNode.setUserObject(dMeta.getURL());
// get metadata about user tables by building a vector of table names
String usertables[] = {"TABLE", "GLOBAL TEMPORARY", "VIEW"};
ResultSet result = dMeta.getTables(null, null, null, usertables);
Vector tables = new Vector();
// sqlbob@users Added remarks.
Vector remarks = new Vector();
while (result.next()) {
tables.addElement(result.getString(3));
remarks.addElement(result.getString(5));
}
result.close();
// For each table, build a tree node with interesting info
for (int i = 0; i < tables.size(); i++) {
String name = (String) tables.elementAt(i);
DefaultMutableTreeNode tableNode = makeNode(name, rootNode);
ResultSet col = dMeta.getColumns(null, null, name, null);
// sqlbob@users Added remarks.
String remark = (String) remarks.elementAt(i);
if ((remark != null) && !remark.trim().equals("")) {
makeNode(remark, tableNode);
}
// With a child for each column containing pertinent attributes
while (col.next()) {
String c = col.getString(4);
DefaultMutableTreeNode columnNode = makeNode(c, tableNode);
String type = col.getString(6);
makeNode("Type: " + type, columnNode);
boolean nullable = col.getInt(11) != DatabaseMetaData.columnNoNulls;
makeNode("Nullable: " + nullable, columnNode);
}
col.close();
DefaultMutableTreeNode indexesNode = makeNode("Indices", tableNode);
ResultSet ind = dMeta.getIndexInfo(null, null, name, false, false);
String oldiname = null;
// A child node to contain each index - and its attributes
while (ind.next()) {
DefaultMutableTreeNode indexNode = null;
boolean nonunique = ind.getBoolean(4);
String iname = ind.getString(6);
if ((oldiname == null || !oldiname.equals(iname))) {
indexNode = makeNode(iname, indexesNode);
makeNode("Unique: " + !nonunique, indexNode);
oldiname = iname;
}
// And the ordered column list for index components
makeNode(ind.getString(9), indexNode);
}
ind.close();
}
// Finally - a little additional metadata on this connection
propertiesNode = makeNode("Properties", rootNode);
makeNode("User: "******"ReadOnly: " + cConn.isReadOnly(), propertiesNode);
makeNode("AutoCommit: " + cConn.getAutoCommit(), propertiesNode);
makeNode("Driver: " + dMeta.getDriverName(), propertiesNode);
makeNode("Product: " + dMeta.getDatabaseProductName(), propertiesNode);
makeNode("Version: " + dMeta.getDatabaseProductVersion(), propertiesNode);
} catch (SQLException se) {
propertiesNode = makeNode("Error getting metadata:", rootNode);
makeNode(se.getMessage(), propertiesNode);
makeNode(se.getSQLState(), propertiesNode);
}
treeModel.nodeStructureChanged(rootNode);
treeModel.reload();
tScrollPane.repaint();
}