|
|
|
package com.fr.design.data.datapane;
|
|
|
|
|
|
|
|
import com.fr.base.svg.IconUtils;
|
|
|
|
import com.fr.data.MultiResultTableData;
|
|
|
|
import com.fr.design.constants.UIConstants;
|
|
|
|
import com.fr.design.data.datapane.management.search.TableDataTreeSearchManager;
|
|
|
|
import com.fr.design.data.tabledata.wrapper.TableDataWrapper;
|
|
|
|
import com.fr.design.gui.itree.refreshabletree.ExpandMutableTreeNode;
|
|
|
|
import com.fr.design.gui.itree.refreshabletree.UserObjectRefreshJTree;
|
|
|
|
import com.fr.design.icon.IconPathConstants;
|
|
|
|
import com.fr.general.ComparatorUtils;
|
|
|
|
import com.fr.general.NameObject;
|
|
|
|
|
|
|
|
import javax.swing.BorderFactory;
|
|
|
|
import javax.swing.JTree;
|
|
|
|
import javax.swing.tree.DefaultMutableTreeNode;
|
|
|
|
import javax.swing.tree.DefaultTreeCellRenderer;
|
|
|
|
import javax.swing.tree.DefaultTreeModel;
|
|
|
|
import javax.swing.tree.TreePath;
|
|
|
|
import java.awt.Color;
|
|
|
|
import java.awt.Component;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.Map;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* TableData Tree
|
|
|
|
*/
|
|
|
|
public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
|
|
|
|
private static final String TABLE_DATA_NODE = "tableData";
|
|
|
|
|
|
|
|
private static final String COLUMN_NODE = "column";
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Constructor.
|
|
|
|
*/
|
|
|
|
public TableDataTree() {
|
|
|
|
super();
|
|
|
|
this.setCellRenderer(tableDataTreeCellRenderer);
|
|
|
|
this.setEditable(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
// CellRenderer
|
|
|
|
private DefaultTreeCellRenderer tableDataTreeCellRenderer = new DefaultTreeCellRenderer() {
|
|
|
|
private static final long serialVersionUID = 1L;
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
|
|
|
|
super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
|
|
|
|
ExpandMutableTreeNode treeNode = (ExpandMutableTreeNode) value;
|
|
|
|
Object userObj = treeNode.getUserObject();
|
|
|
|
if (userObj instanceof String) {
|
|
|
|
// p:这个是column field.
|
|
|
|
this.setIcon(IconUtils.readIcon("/com/fr/design/standard/field"));
|
|
|
|
this.setText((String) userObj);
|
|
|
|
} else if (userObj instanceof NameObject) {
|
|
|
|
NameObject nameObject = (NameObject) userObj;
|
|
|
|
this.setText(nameObject.getName());
|
|
|
|
if (nameObject.getObject() instanceof TableDataWrapper) {
|
|
|
|
TableDataWrapper tableDataWrappe = (TableDataWrapper) nameObject.getObject();
|
|
|
|
this.setIcon(tableDataWrappe.getIcon());
|
|
|
|
} else if (nameObject.getObject() instanceof Integer) {
|
|
|
|
int num = (Integer) nameObject.getObject();
|
|
|
|
if (num == TableDataSourceOP.SERVER_TABLE_DATA) {
|
|
|
|
this.setIcon(IconUtils.readIcon(IconPathConstants.STD_SHOW_ICON_PATH));
|
|
|
|
} else if (num == TableDataSourceOP.STORE_PRECEDURE_DATA) {
|
|
|
|
this.setIcon(IconUtils.readIcon(IconPathConstants.SP_SHOW_ICON_PATH));
|
|
|
|
} else {
|
|
|
|
this.setIcon(IconUtils.readIcon(IconPathConstants.DS_QUERY_ICON_PATH));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
this.setIcon(IconUtils.readIcon("/com/fr/design/images/data/store_procedure.png"));
|
|
|
|
}
|
|
|
|
} else if (userObj == PENDING) {
|
|
|
|
this.setIcon(null);
|
|
|
|
this.setText(PENDING.toString());
|
|
|
|
}
|
|
|
|
this.setBorder(BorderFactory.createEmptyBorder(1, 0, 1, 0));
|
|
|
|
this.setBackgroundNonSelectionColor(UIConstants.TREE_BACKGROUND);
|
|
|
|
this.setTextSelectionColor(Color.WHITE);
|
|
|
|
this.setBackgroundSelectionColor(UIConstants.FLESH_BLUE);
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public DefaultTreeCellRenderer getTableDataTreeCellRenderer() {
|
|
|
|
return tableDataTreeCellRenderer;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setTableDataTreeCellRenderer(DefaultTreeCellRenderer tableDataTreeCellRenderer) {
|
|
|
|
this.tableDataTreeCellRenderer = tableDataTreeCellRenderer;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected void refreshTreeNode(ExpandMutableTreeNode eTreeNode, String childName) {
|
|
|
|
if (interceptRefresh(eTreeNode)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
boolean refreshall = childName.isEmpty();
|
|
|
|
ExpandMutableTreeNode[] newNodes = loadChildTreeNodes(eTreeNode);
|
|
|
|
|
|
|
|
java.util.List<DefaultMutableTreeNode> childTreeNodeList = new java.util.ArrayList<DefaultMutableTreeNode>();
|
|
|
|
for (int i = 0, len = eTreeNode.getChildCount(); i < len; i++) {
|
|
|
|
if (eTreeNode.getChildAt(i) instanceof ExpandMutableTreeNode) {
|
|
|
|
childTreeNodeList.add((ExpandMutableTreeNode) eTreeNode.getChildAt(i));
|
|
|
|
} else {
|
|
|
|
childTreeNodeList.add((DefaultMutableTreeNode) eTreeNode.getChildAt(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
eTreeNode.removeAllChildren();
|
|
|
|
|
|
|
|
for (int ci = 0; ci < newNodes.length; ci++) {
|
|
|
|
Object cUserObject = newNodes[ci].getUserObject();
|
|
|
|
ExpandMutableTreeNode cTreeNode = null;
|
|
|
|
for (int ni = 0, nlen = childTreeNodeList.size(); ni < nlen; ni++) {
|
|
|
|
cTreeNode = (ExpandMutableTreeNode) childTreeNodeList.get(ni);
|
|
|
|
if (ComparatorUtils.equals(cTreeNode.getUserObject(), cUserObject)) {
|
|
|
|
if (!refreshall && !ComparatorUtils.equals(childName, ((NameObject) cUserObject).getName())) {
|
|
|
|
newNodes[ci] = cTreeNode;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
newNodes[ci].setExpanded(cTreeNode.isExpanded());
|
|
|
|
// REPORT-41299 如果建立的是错误的数据集(没有Child的情况)且这个错误数据集处于isExpanded状态,会在后面的if语句中调用getFirstChild()产生异常,因此这里判断一下
|
|
|
|
if (cTreeNode.getChildCount() == 0) {
|
|
|
|
newNodes[ci].setExpanded(false);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (cTreeNode.getFirstChild() instanceof ExpandMutableTreeNode && cTreeNode.isExpanded()) {
|
|
|
|
checkChildNodes(cTreeNode, newNodes[ci]);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
eTreeNode.add(newNodes[ci]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
protected void checkChildNodes(ExpandMutableTreeNode oldNode, ExpandMutableTreeNode newNode) {
|
|
|
|
for (int i = 0; i < oldNode.getChildCount(); i++) {
|
|
|
|
ExpandMutableTreeNode oldChild = (ExpandMutableTreeNode) oldNode.getChildAt(i);
|
|
|
|
for (int j = 0; j < newNode.getChildCount(); j++) {
|
|
|
|
ExpandMutableTreeNode newChild = (ExpandMutableTreeNode) newNode.getChildAt(j);
|
|
|
|
newChild.removeAllChildren();
|
|
|
|
ExpandMutableTreeNode[] nodes = TableDataTree.this.loadChildTreeNodes(newChild);
|
|
|
|
for (int k = 0; k < nodes.length; k++) {
|
|
|
|
newChild.add(nodes[k]);
|
|
|
|
}
|
|
|
|
removePending(newChild);
|
|
|
|
if (ComparatorUtils.equals(oldChild.getUserObject(), newChild.getUserObject())) {
|
|
|
|
newChild.setExpanded(oldChild.isExpanded());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void removePending(ExpandMutableTreeNode treeNode) {
|
|
|
|
if (treeNode.getChildCount() > 1 && ((ExpandMutableTreeNode) treeNode.getFirstChild()).getUserObject() == PENDING) {
|
|
|
|
treeNode.remove(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void refresh4TreeSearch() {
|
|
|
|
ExpandMutableTreeNode root = (ExpandMutableTreeNode) this.getModel().getRoot();
|
|
|
|
refreshTreeNode4TreeSearch(root);
|
|
|
|
((DefaultTreeModel) this.getModel()).reload(root);
|
|
|
|
root.expandCurrentTreeNode(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 主要是处理节点是否应该添加为搜索结果,以及节点是否需要展开
|
|
|
|
*
|
|
|
|
* @param root
|
|
|
|
*/
|
|
|
|
private void refreshTreeNode4TreeSearch(ExpandMutableTreeNode root) {
|
|
|
|
if (interceptRefresh(root)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// 获取数据集子节点
|
|
|
|
ExpandMutableTreeNode[] dsTreeNodes = loadChildTreeNodes(root);
|
|
|
|
root.removeAllChildren();
|
|
|
|
for (ExpandMutableTreeNode dsTreeNode : dsTreeNodes) {
|
|
|
|
if (TableDataTreeSearchManager.getInstance().nodeNameMatches(dsTreeNode.getUserObject().toString())) {
|
|
|
|
// 加载数据列节点
|
|
|
|
loadAndAddChildTreeChild(dsTreeNode);
|
|
|
|
// 处理子节点的展开
|
|
|
|
dealWithNodeExpand(dsTreeNode);
|
|
|
|
// 添加数据集子节点
|
|
|
|
root.add(dsTreeNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 加载所有子节点,并添加到父节点中
|
|
|
|
*
|
|
|
|
* @param treeNode
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
private ExpandMutableTreeNode loadAndAddChildTreeChild(ExpandMutableTreeNode treeNode) {
|
|
|
|
if (isTreeNodeStoreProcedure(treeNode)) {
|
|
|
|
// 如果是存储过程,则再加载一次其子表节点,这里比较坑的就是存储过程不能使用loadChildTreeNodes
|
|
|
|
int tableChildCounts = treeNode.getChildCount();
|
|
|
|
ExpandMutableTreeNode[] childs = new ExpandMutableTreeNode[tableChildCounts];
|
|
|
|
for (int i = 0; i < tableChildCounts; i++) {
|
|
|
|
ExpandMutableTreeNode tableChild = (ExpandMutableTreeNode) treeNode.getChildAt(i);
|
|
|
|
loadAndAddChildTreeChild(tableChild);
|
|
|
|
childs[i] = tableChild;
|
|
|
|
removePending(tableChild);
|
|
|
|
}
|
|
|
|
treeNode.addChildTreeNodes(childs);
|
|
|
|
} else {
|
|
|
|
ExpandMutableTreeNode[] expandMutableTreeNodes = loadChildTreeNodes(treeNode);
|
|
|
|
treeNode.addChildTreeNodes(expandMutableTreeNodes);
|
|
|
|
}
|
|
|
|
removePending(treeNode);
|
|
|
|
return treeNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 处理节点的展开,如果此节点是存储过程,还会处理其子表节点的展开
|
|
|
|
* 只针对数据集节点
|
|
|
|
*
|
|
|
|
* @param treeNode
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
public ExpandMutableTreeNode dealWithNodeExpand(ExpandMutableTreeNode treeNode) {
|
|
|
|
String tableDataName = treeNode.getUserObject().toString();
|
|
|
|
// 主要还是处理存储过程
|
|
|
|
if (isTreeNodeStoreProcedure(treeNode)) {
|
|
|
|
int childCount = treeNode.getChildCount();
|
|
|
|
for (int i = 0; i < childCount; i++) {
|
|
|
|
ExpandMutableTreeNode child = (ExpandMutableTreeNode) treeNode.getChildAt(i);
|
|
|
|
String nodeName = tableDataName + "_" + child.getUserObject().toString();
|
|
|
|
if (TableDataTreeSearchManager.getInstance().nodeCanExpand(nodeName)) {
|
|
|
|
child.setExpanded(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (TableDataTreeSearchManager.getInstance().nodeCanExpand(treeNode.getUserObject().toString())) {
|
|
|
|
treeNode.setExpanded(true);
|
|
|
|
}
|
|
|
|
return treeNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* p:获得选中的NameObject = name + tabledata.
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public NameObject getSelectedNameObject() {
|
|
|
|
TreePath selectedTreePath = this.getSelectionPath();
|
|
|
|
if (selectedTreePath == null) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
|
|
|
|
Object selectedUserObject = selectedTreeNode.getUserObject();
|
|
|
|
ExpandMutableTreeNode parentTreeNode = (ExpandMutableTreeNode) selectedTreeNode.getParent();
|
|
|
|
Object parentUserObject = parentTreeNode.getUserObject();
|
|
|
|
if (parentUserObject instanceof NameObject && ((NameObject) parentUserObject).getObject() instanceof Integer) {
|
|
|
|
if (selectedUserObject instanceof NameObject) {
|
|
|
|
return (NameObject) selectedUserObject;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
parentTreeNode = (ExpandMutableTreeNode) selectedTreeNode.getParent();
|
|
|
|
parentUserObject = parentTreeNode.getUserObject();
|
|
|
|
|
|
|
|
if (parentUserObject != null) {
|
|
|
|
if (!(parentUserObject instanceof NameObject)) {
|
|
|
|
return (NameObject) selectedUserObject;
|
|
|
|
} else {
|
|
|
|
return (NameObject) parentUserObject;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 获得选中的数据集节点的NameObject的数组,只会返回数据集节点的NameObject
|
|
|
|
* 当多选了数据集或数据列时,也只返回选中的数据集
|
|
|
|
*/
|
|
|
|
public NameObject[] getSelectedTableDataNameObjects() {
|
|
|
|
Map<String, List<ExpandMutableTreeNode>> tableDataNodesAndColumnNodes = getSelectedTableDataNodesAndColumnNodes();
|
|
|
|
List<ExpandMutableTreeNode> tableDataNodes = tableDataNodesAndColumnNodes.get(TABLE_DATA_NODE);
|
|
|
|
if (tableDataNodes == null) {
|
|
|
|
return new NameObject[0];
|
|
|
|
}
|
|
|
|
return tableDataNodes.stream().map(node -> (NameObject) node.getUserObject()).toArray(NameObject[]::new);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 获取选中的数据集节点和列名节点
|
|
|
|
* 其中存储过程的子表节点不计入数据集节点中,仅存储过程节点本身计入数据集节点
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
private Map<String, List<ExpandMutableTreeNode>> getSelectedTableDataNodesAndColumnNodes() {
|
|
|
|
TreePath[] selectedTreePaths = this.getSelectionPaths();
|
|
|
|
if (selectedTreePaths == null) {
|
|
|
|
return new HashMap<>();
|
|
|
|
}
|
|
|
|
Map<String, List<ExpandMutableTreeNode>> resultMap = new HashMap<>();
|
|
|
|
List<ExpandMutableTreeNode> tableDataNodes = new ArrayList<>();
|
|
|
|
List<ExpandMutableTreeNode> columnNodes = new ArrayList<>();
|
|
|
|
resultMap.put(TABLE_DATA_NODE, tableDataNodes);
|
|
|
|
resultMap.put(COLUMN_NODE, columnNodes);
|
|
|
|
for (TreePath selectedTreePath : selectedTreePaths) {
|
|
|
|
if (selectedTreePath == null) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
|
|
|
|
if (isTableDataNodes(selectedTreeNode)) {
|
|
|
|
// 数据集节点
|
|
|
|
tableDataNodes.add(selectedTreeNode);
|
|
|
|
} else {
|
|
|
|
// 列名节点
|
|
|
|
columnNodes.add(selectedTreeNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return resultMap;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 获取选中的数据集数量,选中数据列则不计入
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
public int getSelectedTableDataCounts() {
|
|
|
|
return getSelectedTableDataNameObjects().length;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 是否存在单独选了数据列节点,但没选其对应数据集的情况
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
public boolean hasSelectedIndependentColumns() {
|
|
|
|
Map<String, List<ExpandMutableTreeNode>> tableDataNodesAndColumnNodes = getSelectedTableDataNodesAndColumnNodes();
|
|
|
|
List<ExpandMutableTreeNode> tableDataNodes = tableDataNodesAndColumnNodes.get(TABLE_DATA_NODE);
|
|
|
|
List<ExpandMutableTreeNode> columnNodes = tableDataNodesAndColumnNodes.get(COLUMN_NODE);
|
|
|
|
if (columnNodes == null || columnNodes.size() == 0) {
|
|
|
|
// 未选中数据列
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (tableDataNodes == null || tableDataNodes.size() == 0) {
|
|
|
|
// 选中数据列而未选中数据集
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
boolean result = false;
|
|
|
|
for (ExpandMutableTreeNode columnNode : columnNodes) {
|
|
|
|
ExpandMutableTreeNode tableDataNode = getBelongedTableDataNodes(columnNode);
|
|
|
|
if (!tableDataNodes.contains(tableDataNode)) {
|
|
|
|
result = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 获取一个节点归属的数据集层级父节点
|
|
|
|
* @param treeNode
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
private ExpandMutableTreeNode getBelongedTableDataNodes(ExpandMutableTreeNode treeNode) {
|
|
|
|
if (isTableDataNodes(treeNode)) {
|
|
|
|
return treeNode;
|
|
|
|
}
|
|
|
|
return getBelongedTableDataNodes((ExpandMutableTreeNode) treeNode.getParent());
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean isTableDataNodes(ExpandMutableTreeNode treeNode) {
|
|
|
|
if (treeNode == null) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
Object userObject = treeNode.getUserObject();
|
|
|
|
if (userObject instanceof NameObject && ((NameObject) userObject).getObject() instanceof TableDataWrapper) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
public TableDataWrapper[] getSelectedDatas() {
|
|
|
|
TreePath[] selectedTreePaths = this.getSelectionPaths();
|
|
|
|
if (selectedTreePaths == null || selectedTreePaths.length == 0) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
TableDataWrapper[] nameobjs = new TableDataWrapper[selectedTreePaths.length];
|
|
|
|
for (int i = 0; i < selectedTreePaths.length; i++) {
|
|
|
|
TreePath selectedTreePath = selectedTreePaths[i];
|
|
|
|
ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
|
|
|
|
Object selectedUserObject = selectedTreeNode.getUserObject();
|
|
|
|
ExpandMutableTreeNode parentTreeNode = (ExpandMutableTreeNode) selectedTreeNode.getParent();
|
|
|
|
Object parentUserObject = parentTreeNode.getUserObject();
|
|
|
|
if (parentUserObject instanceof NameObject && ((NameObject) parentUserObject).getObject() instanceof Integer) {
|
|
|
|
if (selectedUserObject instanceof NameObject) {
|
|
|
|
Object obj = ((NameObject) selectedUserObject).getObject();
|
|
|
|
if (obj instanceof TableDataWrapper) {
|
|
|
|
nameobjs[i] = (TableDataWrapper) obj;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return new TableDataWrapper[0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nameobjs;
|
|
|
|
}
|
|
|
|
|
|
|
|
public NameObject getRealSelectedNameObject() {
|
|
|
|
TreePath selectedTreePath = this.getSelectionPath();
|
|
|
|
if (selectedTreePath == null) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
|
|
|
|
Object selectedUserObject = selectedTreeNode.getUserObject();
|
|
|
|
if (selectedUserObject instanceof NameObject) {
|
|
|
|
return (NameObject) selectedUserObject;
|
|
|
|
}
|
|
|
|
|
|
|
|
selectedTreeNode = (ExpandMutableTreeNode) selectedTreeNode.getParent();
|
|
|
|
selectedUserObject = selectedTreeNode.getUserObject();
|
|
|
|
if (selectedUserObject instanceof NameObject) {
|
|
|
|
return (NameObject) selectedUserObject;
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p:添加一个NameObject节点.
|
|
|
|
*/
|
|
|
|
public void addNameObject(NameObject no) {
|
|
|
|
if (no == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
DefaultTreeModel treeModel = (DefaultTreeModel) this.getModel();
|
|
|
|
|
|
|
|
// 新建一个放着NameObject的newChildTreeNode,加到Root下面
|
|
|
|
ExpandMutableTreeNode root = (ExpandMutableTreeNode) treeModel.getRoot();
|
|
|
|
|
|
|
|
ExpandMutableTreeNode newChildTreeNode = new ExpandMutableTreeNode(no);
|
|
|
|
root.add(newChildTreeNode);
|
|
|
|
newChildTreeNode.add(new ExpandMutableTreeNode());
|
|
|
|
|
|
|
|
treeModel.reload(root);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 判断此节点是否为存储过程
|
|
|
|
*
|
|
|
|
* @param treeNode
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
public boolean isTreeNodeStoreProcedure(ExpandMutableTreeNode treeNode) {
|
|
|
|
Object userObject = treeNode.getUserObject();
|
|
|
|
if (userObject instanceof NameObject) {
|
|
|
|
NameObject nameObject = (NameObject) userObject;
|
|
|
|
TableDataWrapper tableDataWrapper = (TableDataWrapper) nameObject.getObject();
|
|
|
|
return tableDataWrapper.getTableData() instanceof MultiResultTableData<?>;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|