void deleteNodeParent(DefaultMutableTreeNode parent) throws Exception {
while (parent.getChildCount() != 0) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) parent.getFirstChild();
deleteNodeParent(node);
}
deleteNode(parent);
}
public DefaultMutableTreeNode findNode(DefaultMutableTreeNode parent, String match) {
if (parent == null) return null;
// Commented by Balan on 15/03/03
// String treename = (String)parent.getUserObject ();
// Comment Ends
// Added by Balan on 15/03/03
String treename = "" + ((Hashtable) parent.getUserObject()).get("TREE-NAME");
// Add Ends
if (treename != null) {
if (treename.equals(match)) return parent;
}
if (frame.model.isLeaf(parent)) return null;
Enumeration en = parent.children();
if ((en == null) || (!en.hasMoreElements())) return null;
for (; en.hasMoreElements(); ) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode) en.nextElement();
DefaultMutableTreeNode returnNode = findNode(child, match);
if (returnNode != null) return returnNode;
}
return null;
}
@Override
public void actionPerformed(ActionEvent evt) {
JCheckBoxMenuItem menuItem = (JCheckBoxMenuItem) evt.getSource();
boolean curState = menuItem.isSelected();
TreePath path = resultTree.getSelectionPath();
DefaultMutableTreeNode operNode = (DefaultMutableTreeNode) path.getLastPathComponent();
HyperSearchOperationNode operNodeObj = (HyperSearchOperationNode) operNode.getUserObject();
if (curState) operNodeObj.cacheResultNodes(operNode);
operNode.removeAllChildren();
if (curState) {
Exception excp = null;
try {
operNodeObj.insertTreeNodes(resultTree, operNode);
} catch (Exception ex) {
operNodeObj.restoreFlatNodes(resultTree, operNode);
menuItem.setSelected(false);
excp = ex;
} finally {
((DefaultTreeModel) resultTree.getModel()).nodeStructureChanged(operNode);
expandAllNodes(operNode);
resultTree.scrollPathToVisible(new TreePath(operNode.getPath()));
}
if (excp != null) throw new RuntimeException(excp);
} else operNodeObj.restoreFlatNodes(resultTree, operNode);
operNodeObj.setTreeViewDisplayed(menuItem.isSelected());
}
@Override
public String convertValueToText(
Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
String s = super.convertValueToText(value, selected, expanded, leaf, row, hasFocus);
String newProp = jEdit.getProperty(HIGHLIGHT_PROP);
if (newProp == null || newProp.isEmpty()) return s;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
while (node != null && !(node.getUserObject() instanceof HyperSearchOperationNode)) {
node = (DefaultMutableTreeNode) node.getParent();
}
if (node == null) return s;
if (!newProp.equals(prop)) {
prop = newProp;
Font f = (resultTree != null) ? resultTree.getFont() : UIManager.getFont("Tree.font");
styleTag = HtmlUtilities.style2html(prop, f);
}
SearchMatcher matcher = ((HyperSearchOperationNode) node.getUserObject()).getSearchMatcher();
int i = s.indexOf(": ");
if (i > 0) i += 2;
else i = 0;
Match m;
List<Integer> matches = new ArrayList<Integer>();
while ((m = matcher.nextMatch(s.substring(i), true, true, true, false)) != null) {
matches.add(i + m.start);
matches.add(i + m.end);
i += m.end;
}
return HtmlUtilities.highlightString(s, styleTag, matches);
}
void onEdit() {
DefaultTreeModel model = (DefaultTreeModel) m_tree.getModel();
TreePath path = m_tree.getSelectionPath();
DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node.getParent();
Organization org = (Organization) node.getUserObject();
OrganizationEditorDlg dlg = null;
if (parent == model.getRoot())
dlg =
new OrganizationEditorDlg(
pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(), m_conn, m_sessionid, null, org);
else
dlg =
new OrganizationEditorDlg(
pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(),
m_conn,
m_sessionid,
(DefaultMutableTreeNode) node.getParent(),
org);
dlg.setVisible(true);
if (dlg.getResponse() == JOptionPane.OK_OPTION) {
node.setUserObject(dlg.getOrganization());
model.nodeChanged(node);
}
}
public boolean restoreSelection(TreeSelection treeSelection) {
if (treeSelection.isEmpty()) return false;
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
for (int i = 0; i < root.getChildCount(); i++) {
TreeNode node = root.getChildAt(i);
if (node instanceof MessageNode) {
MessageNode messageNode = (MessageNode) node;
String[] text = messageNode.getText();
if (text.length == 0) continue;
if (Comparing.equal(treeSelection.mySelectedTarget, text[0])) {
TreePath pathToSelect = new TreePath(messageNode.getPath());
for (Enumeration enumeration = messageNode.children(); enumeration.hasMoreElements(); ) {
Object o = enumeration.nextElement();
if (o instanceof MessageNode) {
messageNode = (MessageNode) o;
if (Comparing.equal(treeSelection.mySelectedTask, text[0])) {
pathToSelect = new TreePath(messageNode.getPath());
break;
}
}
}
TreeUtil.selectPath(myTree, pathToSelect);
myTree.expandPath(pathToSelect);
return true;
}
}
}
return false;
}
private static void replaceChildren(
final DefaultMutableTreeNode node, final Collection<? extends ElementNode> arrayList) {
node.removeAllChildren();
for (ElementNode child : arrayList) {
node.add(child);
}
}
private static boolean isToolbarAction(DefaultMutableTreeNode node) {
return node.getParent() != null
&& ((DefaultMutableTreeNode) node.getParent()).getUserObject() instanceof Group
&& ((Group) ((DefaultMutableTreeNode) node.getParent()).getUserObject())
.getName()
.equals(ActionsTreeUtil.MAIN_TOOLBAR);
}
// ===============================================================
// ===============================================================
public Component getTreeCellRendererComponent(
JTree tree,
Object obj,
boolean sel,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
super.getTreeCellRendererComponent(tree, obj, sel, expanded, leaf, row, hasFocus);
setBackgroundNonSelectionColor(background);
setForeground(Color.black);
setBackgroundSelectionColor(Color.lightGray);
if (row == 0) {
// ROOT
setFont(fonts[TITLE]);
setIcon(tango_icon);
} else {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) obj;
if (node.getUserObject() instanceof PollThread) {
setFont(fonts[THREAD]);
setIcon(class_icon);
} else {
setFont(fonts[DEVICE]);
setIcon(cmd_icon);
}
}
return this;
}
/**
* Recursively rebuild the tree nodes.
*
* @param root The full abstract path to the root saved layout directory.
* @param local The current directory relative to root (null if none).
* @param tnode The current parent tree node.
*/
private void rebuildTreeModel(Path root, Path local, DefaultMutableTreeNode tnode) {
TreeSet<Path> subdirs = new TreeSet<Path>();
TreeSet<String> layouts = new TreeSet<String>();
{
Path current = new Path(root, local);
File files[] = current.toFile().listFiles();
if (files != null) {
int wk;
for (wk = 0; wk < files.length; wk++) {
String name = files[wk].getName();
if (files[wk].isDirectory()) subdirs.add(new Path(local, name));
else if (files[wk].isFile()) layouts.add(name);
}
}
}
for (Path subdir : subdirs) {
TreeData data = new TreeData(subdir);
DefaultMutableTreeNode child = new DefaultMutableTreeNode(data, true);
tnode.add(child);
rebuildTreeModel(root, subdir, child);
}
for (String lname : layouts) {
TreeData data = new TreeData(new Path(local, lname), lname);
DefaultMutableTreeNode child = new DefaultMutableTreeNode(data, false);
tnode.add(child);
}
}
@Nullable
private static String getActionId(DefaultMutableTreeNode node) {
return (String)
(node.getUserObject() instanceof String
? node.getUserObject()
: node.getUserObject() instanceof Pair ? ((Pair) node.getUserObject()).first : null);
}
private void collapseTargets() {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
for (int i = 0; i < root.getChildCount(); i++) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) root.getChildAt(i);
myTree.collapsePath(new TreePath(node.getPath()));
}
}
private void goToSelectedNode(int mode) {
TreePath path = resultTree.getSelectionPath();
if (path == null) return;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
Object value = node.getUserObject();
// do nothing if clicked "foo (showing n occurrences in m files)"
if (node.getParent() != resultTreeRoot && value instanceof HyperSearchNode) {
HyperSearchNode n = (HyperSearchNode) value;
Buffer buffer = n.getBuffer(view);
if (buffer == null) return;
EditPane pane;
switch (mode) {
case M_OPEN:
pane = view.goToBuffer(buffer);
break;
case M_OPEN_NEW_VIEW:
pane = jEdit.newView(view, buffer, false).getEditPane();
break;
case M_OPEN_NEW_PLAIN_VIEW:
pane = jEdit.newView(view, buffer, true).getEditPane();
break;
case M_OPEN_NEW_SPLIT:
pane = view.splitHorizontally();
break;
default:
throw new IllegalArgumentException("Bad mode: " + mode);
}
n.goTo(pane);
}
} // }}}
private void doSave() {
ObjectOutputStream objectStream = getObjectOutputStream();
if (objectStream != null) {
try {
System.out.println("Saving " + selectedChildrenPaths.size() + " Selected Generations...");
for (int i = 0; i < selectedChildrenPaths.size(); i++) {
// Get the userObject at the supplied path
Object selectedPath =
((TreePath) selectedChildrenPaths.elementAt(i)).getLastPathComponent();
DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) selectedPath;
objectStream.writeObject(selectedNode.getUserObject());
}
objectStream.close();
System.out.println("Save completed successfully.");
} catch (IOException e) {
System.err.println(e);
}
} else {
System.out.println("Save Selected Files has been aborted!");
}
}
/**
* Called when the selection changed in the tree. Loads the selected certificate.
*
* @param e the event
*/
private void valueChangedPerformed(TreeSelectionEvent e) {
Object o = e.getNewLeadSelectionPath().getLastPathComponent();
if (o instanceof DefaultMutableTreeNode) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) o;
infoTextPane.setText(toString(node.getUserObject()));
}
}
private int compare(DefaultMutableTreeNode node1, DefaultMutableTreeNode node2) {
SearchTOCItem item1, item2;
double confidence1, confidence2;
int hits1, hits2;
item1 = (SearchTOCItem) node1.getUserObject();
confidence1 = item1.getConfidence();
hits1 = item1.hitCount();
item2 = (SearchTOCItem) node2.getUserObject();
confidence2 = item2.getConfidence();
hits2 = item2.hitCount();
// confidence is a penality. The lower the better
if (confidence1 > confidence2) {
// node1 is less than node2
return -1;
} else if (confidence1 < confidence2) {
// node1 is greater than node2
return 1;
} else {
// confidences are the same check the hits
if (hits1 < hits2) {
// node1 is less than node2
return -1;
} else if (hits1 > hits2) {
// node2 is greater than node2
return 1;
}
}
// nodes1 and nodes2 are equivalent
return 0;
}
// reorder the nodes
private void reorder(Vector nodes) {
debug("reorder nodes");
// remove all the children of topNode (they'll be added back later)
topNode.removeAllChildren();
// Create an array of the elements for sorting & copy the elements
// into the array.
DefaultMutableTreeNode[] array = new DefaultMutableTreeNode[nodes.size()];
nodes.copyInto(array);
// Sort the array (Quick Sort)
quickSort(array, 0, array.length - 1);
// Reload the topNode. Everthing is in order now.
for (int i = 0; i < array.length; i++) {
topNode.add((DefaultMutableTreeNode) array[i]);
}
// Tell the tree to repaint itself
((DefaultTreeModel) tree.getModel()).reload();
tree.invalidate();
tree.repaint();
}
private void removeNodeFromParent(DefaultMutableTreeNode node) {
TreeNode parent = node.getParent();
int idx = parent.getIndex(node);
node.removeFromParent();
(getModel()).nodesWereRemoved(parent, new int[] {idx}, new TreeNode[] {node});
}
private ArrayList<TreeNode> childrenToArray(DefaultMutableTreeNode node) {
ArrayList<TreeNode> arrayList = new ArrayList<TreeNode>();
for (int i = 0; i < node.getChildCount(); i++) {
arrayList.add(node.getChildAt(i));
}
return arrayList;
}
/**
* Adds nodes to the specified parent node recurrsively.
*
* @param parent_node the parent node.
* @param list the list of child node names.
*/
protected void addNode(DefaultMutableTreeNode parent_node, Vector list) {
SortableArray array = null;
if (mode == DATE_ORIENTED && parent_node.getLevel() <= 2) {
array = new Array(list.size());
for (int i = 0; i < list.size(); i++)
((Array) array).set(i, Integer.parseInt((String) list.elementAt(i)));
} else {
array = new StringArray(list.size());
for (int i = 0; i < list.size(); i++)
((StringArray) array).set(i, (String) list.elementAt(i));
}
ArrayIndex index = array.sortAscendant();
for (int i = 0; i < array.getArraySize(); i++) {
String name = (String) list.elementAt(index.get(i));
// Converts 1...12 to January...December.
if (mode == DATE_ORIENTED && parent_node.getLevel() == 1) {
int month = Integer.parseInt(name);
name = JulianDay.getFullSpellMonthString(month);
}
DefaultMutableTreeNode node = new DefaultMutableTreeNode(name);
parent_node.add(node);
}
}
// ===============================================================
// ===============================================================
private int getNextThreadNum() {
int num = 0;
for (int i = 0; i < root.getChildCount(); i++) {
DefaultMutableTreeNode th_node = (DefaultMutableTreeNode) root.getChildAt(i);
num = ((PollThread) th_node.getUserObject()).num;
}
return ++num;
}
/** A value has changed. This is used as a TreeSelectionListener. */
public void valueChanged(TreeSelectionEvent e) {
JHelpNavigator navigator = getHelpNavigator();
HelpModel helpmodel = navigator.getModel();
debug("ValueChanged: " + e);
debug(" model: " + helpmodel);
// send selected items into navigator
TreeItem[] items = null;
TreePath[] paths = tree.getSelectionPaths();
if (paths != null) {
items = new TreeItem[paths.length];
for (int i = 0; i < paths.length; i++) {
if (paths[i] != null) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) paths[i].getLastPathComponent();
items[i] = (TreeItem) node.getUserObject();
}
}
}
navigator.setSelectedItems(items);
// change current id only if one items is selected
if (items != null && items.length == 1) {
SearchTOCItem item = (SearchTOCItem) items[0];
if (item != null) {
if (item.getID() != null) {
try {
// navigator.setCurrentID(item.getID());
helpmodel.setCurrentID(item.getID(), item.getName(), navigator);
} catch (InvalidHelpSetContextException ex) {
System.err.println("BadID: " + item.getID());
return;
}
} else if (item.getURL() != null) {
// navigator.setCurrentURL(item.getURL());
helpmodel.setCurrentURL(item.getURL(), item.getName(), navigator);
} else {
// no ID, no URL
return;
}
if (helpmodel instanceof TextHelpModel) {
DefaultHighlight h[] = new DefaultHighlight[item.hitCount()];
int i = 0;
Enumeration enum1 = item.getSearchHits();
while (enum1.hasMoreElements()) {
SearchHit info = (SearchHit) enum1.nextElement();
h[i] = new DefaultHighlight(info.getBegin(), info.getEnd());
i++;
}
// using setHighlights() instead of removeAll + add
// avoids one highlighting event
((TextHelpModel) helpmodel).setHighlights(h);
}
}
}
}
@Nullable
public static TreeNode findNodeWithObject(
final Object object, final TreeModel model, final Object parent) {
for (int i = 0; i < model.getChildCount(parent); i++) {
final DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) model.getChild(parent, i);
if (childNode.getUserObject().equals(object)) return childNode;
}
return null;
}
// ===============================================================
// ===============================================================
private void createThreadsNodes() {
for (int i = 0; i < threadsInfo.size(); i++) {
PollThread thread = threadsInfo.threadAt(i);
// Build node for class with all commansdds as leaf
DefaultMutableTreeNode node = new DefaultMutableTreeNode(thread);
root.add(node);
for (Object obj : thread) node.add(new DefaultMutableTreeNode(obj));
}
}
public static void sort(final DefaultMutableTreeNode node, final Comparator comparator) {
final List<TreeNode> children = childrenToArray(node);
Collections.sort(children, comparator);
node.removeAllChildren();
addChildrenTo(node, children);
for (int i = 0; i < node.getChildCount(); i++) {
sort((DefaultMutableTreeNode) node.getChildAt(i), comparator);
}
}
public void addSelectionPathTo(final Object element) {
DefaultMutableTreeNode node = myAbstractTreeBuilder.getNodeForElement(element);
if (node != null) {
final JTree tree = getTree();
final TreePath path = new TreePath(node.getPath());
if (node == tree.getModel().getRoot() && !tree.isExpanded(path)) tree.expandPath(path);
tree.addSelectionPath(path);
}
}
private MutableTreeNode populatePlot(Plot p) throws SQLException {
DefaultMutableTreeNode tree = new DefaultMutableTreeNode(p);
// tree.add(populateAttributes(p));
Statement stmt = db.statement();
for (Tree t : p.loadTrees(stmt)) {
tree.add(populateTree(t));
}
stmt.close();
return tree;
}
private MutableTreeNode populateNest(Nest n) throws SQLException {
DefaultMutableTreeNode tree = new DefaultMutableTreeNode(n);
// tree.add(populateAttributes(n));
Statement stmt = db.statement();
for (Visit v : n.loadVisits(stmt)) {
tree.add(populateVisit(v));
}
stmt.close();
return tree;
}
private MutableTreeNode populateCavity(Cavity c) throws SQLException {
DefaultMutableTreeNode tree = new DefaultMutableTreeNode(c);
// tree.add(populateAttributes(c));
Statement stmt = db.statement();
for (Nest n : c.loadNests(stmt)) {
tree.add(populateNest(n));
}
stmt.close();
return tree;
}
private MutableTreeNode populateTree(Tree t) throws SQLException {
DefaultMutableTreeNode tree = new DefaultMutableTreeNode(t);
// tree.add(populateAttributes(t));
Statement stmt = db.statement();
for (Cavity c : t.loadCavities(stmt)) {
tree.add(populateCavity(c));
}
stmt.close();
return tree;
}
