package com.vci.client.ui.treeTable;
|
|
import java.util.Enumeration;
|
import java.util.Hashtable;
|
import java.util.Vector;
|
|
import javax.swing.tree.TreeNode;
|
|
public class TreeTableModel extends AbstractTreeTableModel {
|
|
private String[] columnNames = null;
|
private Class[] columnClasses = null;
|
|
public TreeTableModel(Object root, String[] columnNames, Class[] columnClasses) {
|
super(root);
|
if (columnNames == null || columnClasses == null
|
|| (columnNames.length != columnClasses.length)) {
|
columnNames = new String[0];
|
columnClasses = new Class[0];
|
}
|
|
this.columnNames = columnNames;
|
this.columnClasses = columnClasses;
|
}
|
|
public int getColumnCount() {
|
return columnNames.length;
|
}
|
|
public String getColumnName(int column) {
|
return this.columnNames[column];
|
}
|
|
public Class getColumnClass(int column) {
|
return this.columnClasses[column];
|
}
|
|
public Object getValueAt(Object node, int column) {
|
TreeTableNode treeNode = (TreeTableNode) node;
|
try {
|
return treeNode.getPropertyValueByName(columnNames[column]);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
public Object[] getChildren(Object parent) {
|
TreeTableNode baseNode = (TreeTableNode) parent;
|
return baseNode.getChildren();
|
}
|
|
public int getChildCount(Object parent) {
|
Object[] children = getChildren(parent);
|
int i = (children == null) ? 0 : children.length;
|
return i;
|
}
|
|
public Object getChild(Object node, int i) {
|
return getChildren(node)[i];
|
}
|
|
/**
|
* get the root node
|
* @return
|
*/
|
public TreeTableNode getRootNode() {
|
return (TreeTableNode) root;
|
}
|
|
public class TreeTableNode implements TreeNode{
|
|
protected Hashtable htTable = null;
|
private Object obj = null;
|
protected TreeTableNode parent;
|
protected Vector children;
|
private boolean isExpand = false;
|
private boolean isLeaf = false;
|
|
public TreeTableNode(TreeTableNode parent, Object obj) {
|
this.parent = parent;
|
this.obj = obj;
|
}
|
|
public TreeTableNode(Object obj) {
|
this(null, obj);
|
}
|
|
public void setPropertyValueByName(String strName,Object obj) {
|
if (htTable == null) {
|
htTable = new Hashtable();
|
}
|
htTable.put(strName,obj);
|
}
|
|
public Object getPropertyValueByName(String strPropertyName) {
|
if (this.htTable == null) {
|
return "";
|
} else {
|
if (this.htTable.containsKey(strPropertyName)) {
|
return htTable.get(strPropertyName);
|
} else {
|
return "";
|
}
|
}
|
}
|
|
public void setPropertyValues(Hashtable ht) {
|
htTable = (Hashtable)(ht.clone());
|
nodeChanged();
|
}
|
|
public void addChild(TreeTableNode node) {
|
if (this.children == null) {
|
children = new Vector();
|
}
|
children.add(node);
|
|
TreeTableNode[] path = getPath();
|
|
fireTreeStructureChanged(TreeTableModel.this, path, null, null);
|
}
|
|
protected TreeTableNode[] getPathToRoot(TreeNode aNode, int depth) {
|
TreeTableNode[] retNodes;
|
|
if(aNode == null) {
|
if(depth == 0) {
|
return null;
|
} else {
|
retNodes = new TreeTableNode[depth];
|
}
|
} else {
|
depth++;
|
retNodes = getPathToRoot(aNode.getParent(), depth);
|
retNodes[retNodes.length - depth] = (TreeTableNode) aNode;
|
}
|
return retNodes;
|
}
|
|
public boolean loadedChildren() {
|
return (children != null);
|
}
|
|
public void setChildren(Vector newNode) {
|
children = newNode;
|
}
|
|
public TreeTableNode[] getChildren() {
|
if (this.children == null ) {
|
return null;
|
}
|
|
TreeTableNode[] pns = new TreeTableNode[this.children.size()];
|
for(int i = 0; i < pns.length; i++) {
|
pns[i] = (TreeTableNode) (this.children.get(i));
|
}
|
return pns;
|
}
|
|
protected void nodeChanged() {
|
TreeTableNode parent = (TreeTableNode) getParent();
|
if (parent != null) {
|
TreeTableNode[] path = parent.getPath();
|
int[] index = {getIndexOfChild(parent, this)};
|
Object[] children = { this };
|
fireTreeNodesChanged(TreeTableModel.this, path, index,children);
|
}
|
}
|
|
public void removeChild(TreeTableNode pnChild) {
|
if (this.children == null) {
|
return;
|
}
|
try {
|
this.children.remove(pnChild);
|
} catch(Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
public void removeAll() {
|
if (this.children != null) {
|
for(int i = this.children.size()-1; i >= 0; i--) {
|
TreeTableNode pn = ( TreeTableNode ) this.children.get(i);
|
pn.removeAll();
|
removeChild(pn);
|
}
|
}
|
}
|
|
public TreeTableNode[] getPath() {
|
return getPathToRoot(this, 0);
|
}
|
|
public void refreshChildren() {
|
if (this.children == null) {
|
this.children = new Vector();
|
}
|
this.children.clear();
|
}
|
|
public String toString() {
|
return obj.toString();
|
}
|
|
public Object getObj() {
|
return obj;
|
}
|
|
public void setObj(Object obj) {
|
this.obj = obj;
|
}
|
|
public Enumeration children() {
|
// TODO Auto-generated method stub
|
return null;
|
}
|
|
public boolean getAllowsChildren() {
|
// TODO Auto-generated method stub
|
return false;
|
}
|
|
public TreeNode getChildAt(int childIndex) {
|
if (children == null) {
|
return null;
|
}
|
int size = children.size();
|
if (size == 0) {
|
return null;
|
}
|
if (childIndex < size) {
|
return (TreeTableNode)children.get(childIndex);
|
} else {
|
return null;
|
}
|
}
|
|
public int getChildCount() {
|
// TODO Auto-generated method stub
|
return 0;
|
}
|
|
public int getIndex(TreeNode node) {
|
// TODO Auto-generated method stub
|
return 0;
|
}
|
|
public TreeNode getParent() {
|
return this.parent;
|
}
|
|
public void setLeaf(boolean isLeaf) {
|
this.isLeaf = isLeaf;
|
}
|
|
public boolean isLeaf() {
|
return isLeaf;
|
}
|
|
/**
|
* @return Returns the isExpand.
|
*/
|
public boolean isExpand() {
|
return isExpand;
|
}
|
/**
|
* @param isExpand The isExpand to set.
|
*/
|
public void setExpand(boolean isExpand) {
|
this.isExpand = isExpand;
|
}
|
}
|
}
|
