private void populateNetworkTree() {
DefaultTreeModel tree = (DefaultTreeModel) networkJTree.getModel();
DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getRoot();
root.removeAllChildren();
DefaultMutableTreeNode networkNode;
DefaultMutableTreeNode stateNode;
DefaultMutableTreeNode cityNode;
ArrayList<Network> networkList = system.getNetworkList();
for (int i = 0; i < networkList.size(); i++) {
Network country = networkList.get(i);
networkNode = new DefaultMutableTreeNode(country.getNetworkname());
root.insert(networkNode, i);
ArrayList<Network> stateList = country.getSubnetworklist();
DefaultMutableTreeNode enterpriseNode;
for (int j = 0; j < stateList.size(); j++) {
Network state = stateList.get(j);
stateNode = new DefaultMutableTreeNode(state.getNetworkname());
networkNode.insert(stateNode, j);
ArrayList<Network> cityList = state.getSubnetworklist();
for (int k = 0; k < cityList.size(); k++) {
Network city = cityList.get(k);
cityNode = new DefaultMutableTreeNode(city.getNetworkname());
stateNode.insert(cityNode, k);
}
}
}
tree.reload();
}
private static void addPathToActionsTree(JTree tree, ActionUrl url) {
final TreePath treePath = CustomizationUtil.getTreePath(tree, url);
if (treePath == null) return;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) treePath.getLastPathComponent();
final int absolutePosition = url.getAbsolutePosition();
if (node.getChildCount() >= absolutePosition && absolutePosition >= 0) {
if (url.getComponent() instanceof Group) {
node.insert(ActionsTreeUtil.createNode((Group) url.getComponent()), absolutePosition);
} else {
node.insert(new DefaultMutableTreeNode(url.getComponent()), absolutePosition);
}
}
}
private void buildTreeFromString(DefaultTreeModel model, final String str) {
// Fetch the root node
DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
// Split the string around the delimiter
String[] strings = str.split("/");
// Create a node object to use for traversing down the tree as it
// is being created
DefaultMutableTreeNode node = root;
// Iterate of the string array
for (String s : strings) {
// Look for the index of a node at the current level that
// has a value equal to the current string
int index = childIndex(node, s);
// Index less than 0, this is a new node not currently present on
// the tree
if (index < 0) {
// Add the new node
DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(s);
node.insert(newChild, node.getChildCount());
node = newChild;
}
// Else, existing node, skip to the next string
else {
node = (DefaultMutableTreeNode) node.getChildAt(index);
}
}
}
public void populateTree() {
DefaultTreeModel model = (DefaultTreeModel) JTree.getModel();
ArrayList<Network> networkList = system.getNetworkList();
ArrayList<Enterprise> enterpriseList;
ArrayList<Organization> organizationList;
Network network;
Enterprise enterprise;
Organization organization;
DefaultMutableTreeNode networks = new DefaultMutableTreeNode("Networks");
DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
root.removeAllChildren();
root.insert(networks, 0);
DefaultMutableTreeNode networkNode;
DefaultMutableTreeNode enterpriseNode;
DefaultMutableTreeNode organizationNode;
for (int i = 0; i < networkList.size(); i++) {
network = networkList.get(i);
networkNode = new DefaultMutableTreeNode(network.getName());
networks.insert(networkNode, i);
enterpriseList = network.getEnterpriseDirectory().getEnterpriseList();
for (int j = 0; j < enterpriseList.size(); j++) {
enterprise = enterpriseList.get(j);
enterpriseNode = new DefaultMutableTreeNode(enterprise.getName());
networkNode.insert(enterpriseNode, j);
organizationList = enterprise.getOrganizationDirectory().getOrganizationList();
for (int k = 0; k < organizationList.size(); k++) {
organization = organizationList.get(k);
organizationNode = new DefaultMutableTreeNode(organization.getName());
enterpriseNode.insert(organizationNode, k);
}
}
}
model.reload();
}
public static void moveSelectedRow(final JTree tree, final int direction) {
final TreePath selectionPath = tree.getSelectionPath();
final DefaultMutableTreeNode treeNode =
(DefaultMutableTreeNode) selectionPath.getLastPathComponent();
final DefaultMutableTreeNode parent = (DefaultMutableTreeNode) treeNode.getParent();
final int idx = parent.getIndex(treeNode);
parent.remove(treeNode);
parent.insert(treeNode, idx + direction);
((DefaultTreeModel) tree.getModel()).reload(parent);
selectNode(tree, treeNode);
}
private static void insertNodeAlphabetically(
DefaultMutableTreeNode parent, DefaultMutableTreeNode newChild) {
String strNewChild = getDisplayName(newChild);
int insertAt = 0;
int parentChildren = parent.getChildCount();
while (insertAt < parentChildren) {
String strParentsChild = getDisplayName((DefaultMutableTreeNode) parent.getChildAt(insertAt));
if (strNewChild.compareToIgnoreCase(strParentsChild) < 0) break;
++insertAt;
}
parent.insert(newChild, insertAt);
}
/** {@inheritDoc} */
@Override
public void insert(final MutableTreeNode aNewChild, final int aChildIndex) {
super.insert(aNewChild, aChildIndex);
Object newChildUserObject = ((ElementTreeNode) aNewChild).getUserObject();
if ((this.userObject instanceof ElementGroup)
&& (newChildUserObject instanceof SignalElement)) {
// Move the actual element as well...
((ElementGroup) this.userObject)
.moveChannel((SignalElement) newChildUserObject, aChildIndex);
}
}
/**
* Gets invoked when changes occur to the contents of the list, and updates the nodes of the tree
* model accordingly. It the invokes <code>reload(node)</code> on the tree model for the affected
* node so changes are reflected in the <code>JTree</code>
*
* @see ca.odell.glazedlists.event.ListEventListener#listChanged
* (ca.odell.glazedlists.event.ListEvent)
*/
public void listChanged(ListEvent listChanges) {
while (listChanges.next()) {
int type = listChanges.getType();
int index = listChanges.getIndex();
if (type == ListEvent.INSERT) {
Object element = listChanges.getSourceList().get(index);
DefaultMutableTreeNode newNode = createChildNode(node, element);
node.insert(newNode, index);
} else {
if (type == ListEvent.UPDATE) {
node.remove(index);
Object element = listChanges.getSourceList().get(index);
DefaultMutableTreeNode newNode = createChildNode(node, element);
node.insert(newNode, index);
} else {
if (type == ListEvent.DELETE) {
node.remove(index);
}
}
}
}
treeModel.reload(node);
}
public void addMessages(AntMessage[] messages) {
DefaultMutableTreeNode parentNode =
(DefaultMutableTreeNode) myParentPath.getLastPathComponent();
int[] indices = new int[messages.length];
for (int i = 0; i < messages.length; i++) {
AntMessage message = messages[i];
MessageNode messageNode = createMessageNode(message);
indices[i] = parentNode.getChildCount();
parentNode.insert(messageNode, indices[i]);
myMessageItems.add(messageNode);
}
myTreeModel.nodesWereInserted(parentNode, indices);
handleExpansion();
}
// {{{ restoreFlatNodes() method
public void restoreFlatNodes(JTree resultTree, DefaultMutableTreeNode operNode) {
for (int i = 0; i < resultNodes.size(); i++) {
DefaultMutableTreeNode element = resultNodes.get(i);
if (element.getUserObject() instanceof HyperSearchFileNode)
((HyperSearchFileNode) element.getUserObject()).showFullPath = true;
operNode.insert(element, operNode.getChildCount());
}
((DefaultTreeModel) resultTree.getModel()).nodeStructureChanged(operNode);
for (Enumeration e = operNode.children(); e.hasMoreElements(); ) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.nextElement();
resultTree.expandPath(new TreePath(node.getPath()));
}
resultTree.scrollPathToVisible(new TreePath(operNode.getPath()));
} // }}}
private void updateListOfMostRecentAlgorithms() {
final boolean bShowMostRecent =
new Boolean(SextanteGUI.getSettingParameterValue(SextanteGeneralSettings.SHOW_MOST_RECENT))
.booleanValue();
if (bShowMostRecent) {
final GeoAlgorithm[] recent = History.getRecentlyUsedAlgs();
final DefaultMutableTreeNode recentNode =
new DefaultMutableTreeNode(Sextante.getText("RecentAlgorithms"));
for (int i = 0; i < recent.length; i++) {
final DefaultMutableTreeNode node = new DefaultMutableTreeNode(recent[i]);
recentNode.add(node);
}
final DefaultMutableTreeNode mainNode =
(DefaultMutableTreeNode) new TreePath(jTree.getModel().getRoot()).getLastPathComponent();
mainNode.remove(0);
mainNode.insert(recentNode, 0);
}
}
protected void addNewGroup() {
final DefaultMutableTreeNode root =
(DefaultMutableTreeNode)
((DefaultMutableTreeNode) (tree.getModel().getRoot())).getFirstChild();
DefaultMutableTreeNode node = root;
if (node.getChildCount() > 0) {
node = (DefaultMutableTreeNode) node.getFirstChild();
}
if (tree.getSelectionPath() != null) {
node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
}
if (node != root) {
DefaultMutableTreeNode newNode =
new ActivableMutableTreeNode(new Group("group" + node.getParent().getChildCount() + 1));
final DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node.getParent();
parent.insert(newNode, parent.getIndex(node));
newModel.reload();
tree.setSelectionPath(new TreePath(newModel.getPathToRoot(newNode)));
}
}
private static void movePathInActionsTree(JTree tree, ActionUrl url) {
final TreePath treePath = CustomizationUtil.getTreePath(tree, url);
if (treePath != null) {
if (treePath.getLastPathComponent() != null) {
final DefaultMutableTreeNode parent =
((DefaultMutableTreeNode) treePath.getLastPathComponent());
final int absolutePosition = url.getAbsolutePosition();
final int initialPosition = url.getInitialPosition();
if (parent.getChildCount() > absolutePosition && absolutePosition >= 0) {
if (parent.getChildCount() > initialPosition && initialPosition >= 0) {
final DefaultMutableTreeNode child =
(DefaultMutableTreeNode) parent.getChildAt(initialPosition);
if (child.getUserObject().equals(url.getComponent())) {
parent.remove(child);
parent.insert(child, absolutePosition);
}
}
}
}
}
}
private void addNodeInSortedOrder(
final DefaultMutableTreeNode parent, final DefaultMutableTreeNode child) {
final int n = parent.getChildCount();
if (n == 0) {
parent.add(child);
return;
}
final Collator collator = Collator.getInstance();
collator.setStrength(Collator.PRIMARY);
DefaultMutableTreeNode node = null;
for (int i = 0; i < n; i++) {
node = (DefaultMutableTreeNode) parent.getChildAt(i);
try {
if (collator.compare(node.toString(), child.toString()) > 0) {
parent.insert(child, i);
return;
}
} catch (final Exception e) {
}
}
parent.add(child);
}
/**
* Fills the tree with the algorithms that match a search criteria
*
* @param sSearchString The search string to look for in the algorithms context help
* @param bSearchInFiles true if it should search in help files. if false, it will only search in
* algorithm names
* @return the number of algorithms that match the given criteria
*/
public int fillTree(final String sSearchString, final boolean bSearchInHelpFiles) {
m_sLastSearchString = sSearchString;
m_bLastSearchIncludedHelpFiles = bSearchInHelpFiles;
int iCount = 0;
String sGroup, sSubgroup;
final DefaultMutableTreeNode mainNode =
new DefaultMutableTreeNode(Sextante.getText("Algorithms"));
final HashMap<Object, HashMap<String, HashMap<String, DefaultMutableTreeNode>>> groups =
new HashMap<Object, HashMap<String, HashMap<String, DefaultMutableTreeNode>>>();
setCursor(new Cursor(Cursor.WAIT_CURSOR));
// algorithms
final HashMap<String, HashMap<String, GeoAlgorithm>> algs = Sextante.getAlgorithms();
final Set<String> groupKeys = algs.keySet();
final Iterator<String> groupIter = groupKeys.iterator();
while (groupIter.hasNext()) {
final String groupKey = groupIter.next();
final HashMap<String, GeoAlgorithm> groupAlgs = algs.get(groupKey);
final Set keys = groupAlgs.keySet();
final Iterator iter = keys.iterator();
while (iter.hasNext()) {
final GeoAlgorithm alg = groupAlgs.get(iter.next());
if (m_Filter.accept(alg)) {
if (bSearchInHelpFiles) {
if (!HelpIO.containsStringInHelpFile(alg, sSearchString)) {
continue;
}
} else {
if ((sSearchString != null) && !alg.getName().toLowerCase().contains(sSearchString)) {
continue;
}
}
iCount++;
final AlgorithmGroupConfiguration conf =
AlgorithmGroupsOrganizer.getGroupConfiguration(alg);
if (conf != null) {
if (!conf.isShow()) {
continue;
}
sGroup = conf.getGroup();
sSubgroup = conf.getSubgroup();
} else {
sGroup = groupKey;
sSubgroup = alg.getGroup();
}
HashMap<String, HashMap<String, DefaultMutableTreeNode>> group = groups.get(sGroup);
if (group == null) {
group = new HashMap<String, HashMap<String, DefaultMutableTreeNode>>();
groups.put(sGroup, group);
}
HashMap<String, DefaultMutableTreeNode> subgroup = group.get(sSubgroup);
if (subgroup == null) {
subgroup = new HashMap<String, DefaultMutableTreeNode>();
group.put(sSubgroup, subgroup);
}
subgroup.put(alg.getName(), new DefaultMutableTreeNode(alg));
}
}
}
// toolbox actions
final HashMap<NameAndIcon, ArrayList<ToolboxAction>> allActions =
SextanteGUI.getToolboxActions();
final Set<NameAndIcon> actionsKeys = allActions.keySet();
final Iterator<NameAndIcon> actionsIter = actionsKeys.iterator();
while (actionsIter.hasNext()) {
final NameAndIcon nai = actionsIter.next();
final ArrayList<ToolboxAction> actions = allActions.get(nai);
for (int i = 0; i < actions.size(); i++) {
final ToolboxAction ita = actions.get(i);
if ((sSearchString != null) && !ita.getName().toLowerCase().contains(sSearchString)) {
continue;
}
iCount++;
sSubgroup = ita.getGroup();
HashMap<String, HashMap<String, DefaultMutableTreeNode>> group = groups.get(nai.getName());
if (group == null) {
group = groups.get(nai);
}
if (group == null) {
group = new HashMap<String, HashMap<String, DefaultMutableTreeNode>>();
groups.put(nai, group);
}
HashMap<String, DefaultMutableTreeNode> subgroup = group.get(sSubgroup);
if (subgroup == null) {
subgroup = new HashMap<String, DefaultMutableTreeNode>();
group.put(sSubgroup, subgroup);
}
subgroup.put(ita.getName(), new DefaultMutableTreeNode(ita));
}
}
final Set<Object> set = groups.keySet();
final Iterator<Object> iter = set.iterator();
while (iter.hasNext()) {
final Object key = iter.next();
final DefaultMutableTreeNode node = new DefaultMutableTreeNode(key);
addNodeInSortedOrder(mainNode, node);
final HashMap<String, HashMap<String, DefaultMutableTreeNode>> g = groups.get(key);
final Set<String> set2 = g.keySet();
final Iterator<String> iter2 = set2.iterator();
while (iter2.hasNext()) {
final String sKey2 = iter2.next();
final DefaultMutableTreeNode node2 = new DefaultMutableTreeNode(sKey2);
addNodeInSortedOrder(node, node2);
final HashMap<String, DefaultMutableTreeNode> g2 = g.get(sKey2);
final Set<String> set3 = g2.keySet();
final Iterator<String> iter3 = set3.iterator();
while (iter3.hasNext()) {
final String sKey3 = iter3.next();
final DefaultMutableTreeNode node3 = g2.get(sKey3);
addNodeInSortedOrder(node2, node3);
}
}
}
final boolean bShowMostRecent =
new Boolean(SextanteGUI.getSettingParameterValue(SextanteGeneralSettings.SHOW_MOST_RECENT))
.booleanValue();
if (bShowMostRecent) {
final GeoAlgorithm[] recent = History.getRecentlyUsedAlgs();
final DefaultMutableTreeNode recentNode =
new DefaultMutableTreeNode(Sextante.getText("RecentAlgorithms"));
for (int i = 0; i < recent.length; i++) {
final DefaultMutableTreeNode node = new DefaultMutableTreeNode(recent[i]);
recentNode.add(node);
}
mainNode.insert(recentNode, 0);
}
setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
jTree.setModel(new DefaultTreeModel(mainNode));
if (sSearchString != null) {
expandAll();
}
m_ParentDialog.setAlgorithmsCount(iCount);
return iCount;
}
// {{{ insertTreeNodes() method
public void insertTreeNodes(JTree resultTree, DefaultMutableTreeNode operNode) {
String fileSep = System.getProperty("file.separator");
String fileSepRegex = System.getProperty("file.separator");
if (fileSep.equals("\\")) fileSepRegex = "\\\\";
// find the highest level common path
String[] topPathTmp = null;
int topPathNdx = -1;
for (int i = 0; i < resultNodes.size(); i++) {
DefaultMutableTreeNode fileTreeNode = resultNodes.get(i);
Object obj = fileTreeNode.getUserObject();
if (!(obj instanceof HyperSearchFileNode)) continue;
HyperSearchFileNode fileNode = (HyperSearchFileNode) obj;
int pos = fileNode.path.lastIndexOf(fileSep);
String pathName = fileNode.path.substring(0, pos);
String[] paths = pathName.split(fileSepRegex);
if (topPathNdx == -1) {
topPathNdx = paths.length;
topPathTmp = paths;
} else if (paths.length < topPathNdx) {
topPathNdx = paths.length;
topPathTmp = paths;
} else {
for (int ndx = 0; ndx < topPathNdx; ndx++) {
if (!paths[ndx].equals(topPathTmp[ndx])) {
topPathNdx = ndx;
break;
}
}
}
}
String[] topPath = new String[topPathNdx];
String topPathPath = "";
for (int ndx = 0; ndx < topPathNdx; ndx++) {
topPath[ndx] = topPathTmp[ndx];
topPathPath = topPathPath.concat(topPath[ndx] + fileSep);
}
Map<String, DefaultMutableTreeNode> treeNodes = new HashMap<String, DefaultMutableTreeNode>();
HyperSearchFolderNode folderNode = new HyperSearchFolderNode(new File(topPathPath), true);
DefaultMutableTreeNode folderTreeNode = new DefaultMutableTreeNode(folderNode);
operNode.insert(folderTreeNode, operNode.getChildCount());
treeNodes.put(topPathPath, folderTreeNode);
for (int i = 0; i < resultNodes.size(); i++) {
DefaultMutableTreeNode fileTreeNode = resultNodes.get(i);
Object obj = fileTreeNode.getUserObject();
if (!(obj instanceof HyperSearchFileNode)) continue;
HyperSearchFileNode fileNode = (HyperSearchFileNode) obj;
fileNode.showFullPath = false;
int pos = fileNode.path.lastIndexOf(fileSep);
String pathName = fileNode.path.substring(0, pos);
String[] paths = pathName.split(fileSepRegex);
DefaultMutableTreeNode insNode = folderTreeNode;
String partialPath = topPathPath;
for (int ndx = topPathNdx; ndx < paths.length; ndx++) {
partialPath = partialPath.concat(paths[ndx] + fileSep);
DefaultMutableTreeNode tmpNode = treeNodes.get(partialPath);
if (tmpNode == null) {
HyperSearchFolderNode tmpFolderNode =
new HyperSearchFolderNode(new File(partialPath), false);
tmpNode = new DefaultMutableTreeNode(tmpFolderNode);
insNode.insert(tmpNode, insNode.getChildCount());
treeNodes.put(partialPath, tmpNode);
}
insNode = tmpNode;
}
insNode.insert(fileTreeNode, insNode.getChildCount());
treeNodes.put(fileNode.path, insNode);
}
} // }}}
/**
* Performs a "live-update" to the original DefaultMutableTreeNode by reconsiling the differences
* between it and a given updated DefaultMutableTreeNode. The resulting original
* DefaultMutableTreeNode will look identical to the updated node. Appropriate events will fire to
* keep the GUI consistant with any changes that were made to the model.
*
* @param original the model's existing node
* @param updated the node representing the model node's new state
*/
private void reconcileNodes(DefaultMutableTreeNode original, DefaultMutableTreeNode updated) {
SVNTreeNodeData originalData = (SVNTreeNodeData) original.getUserObject();
SVNTreeNodeData updatedData = (SVNTreeNodeData) updated.getUserObject();
if (!originalData.equals(updatedData)) {
originalData.copyNodeValues(updatedData);
}
int originalChildCount = original.getChildCount();
int insertionPoint = 0;
// loop through the original node's children
for (int i = insertionPoint; i < originalChildCount; i++) {
// loop through remaining updated node's children
boolean found = false;
DefaultMutableTreeNode originalChildNode =
(DefaultMutableTreeNode) original.getChildAt(insertionPoint);
SVNTreeNodeData originalChildData = (SVNTreeNodeData) originalChildNode.getUserObject();
while (updated.children().hasMoreElements()) {
DefaultMutableTreeNode updatedChildNode =
(DefaultMutableTreeNode) updated.children().nextElement();
SVNTreeNodeData updatedChildData = (SVNTreeNodeData) updatedChildNode.getUserObject();
if (originalChildData.getPath().equals(updatedChildData.getPath())) {
// same resource, check equality
insertionPoint++;
found = true;
// remove from updated list so we know we handled this node
updated.remove(updatedChildNode);
if (!originalChildData.equals(updatedChildData)) {
// same resource, different values -- update
originalChildData.copyNodeValues(updatedChildData);
reconcileNodes(originalChildNode, updatedChildNode);
((DefaultTreeModel) this.getModel()).nodeChanged(originalChildNode);
break;
} else {
// same values, do nothing
reconcileNodes(originalChildNode, updatedChildNode);
break;
}
} else {
// different resources
// does updated node's child need to be inserted before original node's child?
if (updatedChildData.getPath().compareTo(originalChildData.getPath()) < 0) {
original.insert(updatedChildNode, insertionPoint);
((DefaultTreeModel) this.getModel())
.nodesWereInserted(original, new int[] {insertionPoint});
insertionPoint++;
// inserting the node into the original has the side-effect of removing it from the
// updated
// node, just keep going until we've handled all children, or until the remaining
// children
// come after the last original node
} else {
break;
}
}
}
if (!found) {
original.remove(insertionPoint);
((DefaultTreeModel) this.getModel())
.nodesWereRemoved(
original, new int[] {insertionPoint}, new Object[] {originalChildNode});
}
}
// add any remaining new child nodes
while (updated.children().hasMoreElements()) {
DefaultMutableTreeNode updatedChildNode =
(DefaultMutableTreeNode) updated.children().nextElement();
original.add(updatedChildNode);
// adding the new node to the original has the side-effect of removing it from the updated
// node's children
// so we just keep going until no children remain
((DefaultTreeModel) this.getModel())
.nodesWereInserted(original, new int[] {insertionPoint++});
}
}