You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
468 lines
19 KiB
468 lines
19 KiB
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; |
|
} |
|
}
|
|
|