 | |
|
February 15, 2000 This issue presents tips, techniques, and sample code for the following topics: This issue of the JDC Tech Tips is written by Glen McCluskey. These tips were developed using Java 2 SDK, Standard Edition, v 1.2.2, and are not guaranteed to work with other versions.
|
testing
one
1.1
two
2.1
three
3.1
3.2
3.3
|
The root node, testing, has three children. These child nodes have children as well. A node with no children, such as 3.2, is a leaf node.
Nodes are represented by the DefaultMutableTreeNode class, which
implements the interfaces TreeNode and MutableTreeNode.
Mutable means that the node can change, by adding or deleting
children, or by changing the user object.
Here is a simple example of using JTree:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import java.util.Vector;
public class JTreeDemo {
public static void main(String args[]) {
JFrame frame = new JFrame("JTree Demo");
// handle window close
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
JPanel panel1 = new JPanel();
// set up tree root and nodes
DefaultMutableTreeNode root =
new DefaultMutableTreeNode("testing");
DefaultMutableTreeNode one =
new DefaultMutableTreeNode("one");
one.add(new DefaultMutableTreeNode("1.1"));
one.add(new DefaultMutableTreeNode("1.2"));
DefaultMutableTreeNode two =
new DefaultMutableTreeNode("two");
two.add(new DefaultMutableTreeNode("2.1"));
two.add(new DefaultMutableTreeNode("2.2"));
DefaultMutableTreeNode three =
new DefaultMutableTreeNode("three");
Vector vec = new Vector();
for (int i = 1; i <= 25; i++)
vec.addElement("3." + i);
JTree.DynamicUtilTreeNode.createChildren(three, vec);
root.add(one);
root.add(two);
root.add(three);
// set up tree and scroller for it
// also set text selection color to red
JTree jt = new JTree(root);
DefaultTreeCellRenderer tcr =
(DefaultTreeCellRenderer)jt.getCellRenderer();
tcr.setTextSelectionColor(Color.red);
JScrollPane jsp = new JScrollPane(jt);
jsp.setPreferredSize(new Dimension(200, 300));
// set text field for echoing selections
JPanel panel2 = new JPanel();
final JTextField tf = new JTextField(25);
panel2.add(tf);
// handle selections in the tree
TreeSelectionListener listen;
listen = new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e) {
// get selected path
TreePath path = e.getPath();
int cnt = path.getPathCount();
StringBuffer sb = new StringBuffer();
// pick out the path components
for (int i = 0; i < cnt; i++) {
String s =
path.getPathComponent(i).toString();
sb.append(s);
if (i + 1 != cnt)
sb.append("#");
}
tf.setText(sb.toString());
}
};
jt.addTreeSelectionListener(listen);
panel1.add(jsp);
frame.getContentPane().add("North", panel1);
frame.getContentPane().add("South", panel2);
frame.setLocation(100, 100);
frame.pack();
frame.setVisible(true);
}
}
|
The node structure for the tree is constructed in a straightforward way. As nodes are created:
Print-friendly Version
DefaultMutableTreeNode one =
new DefaultMutableTreeNode("one");
one.add(new DefaultMutableTreeNode("1.1"));
one.add(new DefaultMutableTreeNode("1.2"));
they are added to the parent node:
root.add(one);
Creating nodes one at a time, however, is tedious for large
trees. So the demo illustrates an alternative. This approach
uses the createChildren method of the JTree.DynamicUtilTreeNode
class to create a series of nodes from a Vector object.
DefaultMutableTreeNode three =
new DefaultMutableTreeNode("three");
Vector vec = new Vector();
for (int i = 1; i <= 25; i++)
vec.addElement("3." + i);
JTree.DynamicUtilTreeNode.createChildren(three, vec);
|
In this case, it adds 25 children to the "three" node.
Once a tree is set up and displayed, how do you handle node selection in the tree? The demo shows how to set up a tree selection listener, and get and display a path. The path is a sequence of nodes from the root to the currently-selected node in the tree. A path might be:
testing#three#3.7
Notice that when you select a node in the tree the path is displayed in the lower text box.
There are many other aspects of JTree. For example, the class
DefaultTreeCellRenderer allows you to control the way nodes are
displayed. The demo above uses cell renderers, in a basic way;
it specifies that the current selection should be displayed
in red. But there's more that you can do with this class. For
example, you can use it to specify an icon to be displayed
when nodes are drawn.
Click to view Source code for this tip, or right-click to download.
|
The December 14, 1999 issue of the Tech Tips, discussed how RMI (Remote Method Invocation) can be used to
communicate between programs. Another technique for communication
is the Runtime.exec method. You can use this method to invoke
a program from within a running Java application. Runtime.exec
also allows you to perform operations related to the program, such
as control the program's standard input and output, wait until it
completes execution, and get its exit status. Here's a simple C
application that illustrates these features:
#include <stdio.h>
int main() {
printf("testing\n");
return 0;
}
|
This application writes a string "testing" to standard output, and then terminates with an exit status of 0.
To execute this simple program within a Java application, compile the C application:
$ cc test.c -o test
(your C compiler might require different parameters) and then invoke the program using this Java code:
import java.io.*;
import java.util.ArrayList;
public class ExecDemo {
static public String[] runCommand(String cmd)
throws IOException {
// set up list to capture command output lines
ArrayList list = new ArrayList();
// start command running
Process proc = Runtime.getRuntime().exec(cmd);
// get command's output stream and
// put a buffered reader input stream on it
InputStream istr = proc.getInputStream();
BufferedReader br =
new BufferedReader(new InputStreamReader(istr));
// read output lines from command
String str;
while ((str = br.readLine()) != null)
list.add(str);
// wait for command to terminate
try {
proc.waitFor();
}
catch (InterruptedException e) {
System.err.println("process was interrupted");
}
// check its exit value
if (proc.exitValue() != 0)
System.err.println("exit value was non-zero");
// close stream
br.close();
// return list of strings to caller
return (String[])list.toArray(new String[0]);
}
public static void main(String args[]) throws IOException {
try {
// run a command
String outlist[] = runCommand("test");
// display its output
for (int i = 0; i < outlist.length; i++)
System.out.println(outlist[i]);
}
catch (IOException e) {
System.err.println(e);
}
}
}
|
The demo calls a method runCommand to actually run the program.
String outlist[] = runCommand("test");
This method hooks an input stream to the program's output stream, so that it can read the program's output, and save it into a list of strings.
InputStream istr = proc.getInputStream();
BufferedReader br =
new BufferedReader(new InputStreamReader(istr));
String str;
while ((str = br.readLine()) != null)
list.add(str);
|
After all the output has been read, waitFor is called to
wait on the program to terminate, and then exitValue is called to
get the exit value of the program. If you've done much systems
programming, for example with UNIX system calls, this approach
will be a familiar one. (This example assumes that the current
directory is in your shell search path; more on this subject
below).
If you're on a UNIX system, you can replace:
runCommand("test");
with:
runCommand("ls -l");
to get a full (long) listing of files in the current directory.
But getting a listing in this way highlights a fundamental
weakness of using Runtime.exec -- the programs you invoke aren't
necessarily portable. That is, Runtime.exec is portable, and
exists across different Java implementations, but the invoked
programs are not. There's no program named "ls" on Windows
systems.
Suppose that you're running Windows NT and you decide to remedy this problem by saying:
runCommand("dir");
where "dir" is the equivalent command to "ls". This doesn't work,
because "dir" is not an executable program. Instead it is
built into the shell (command interpreter) CMD.EXE. So you need
to say:
runCommand("cmd /c dir");
where "cmd /c command" says "invoke a shell and execute the single specified command and then exit." Similarly, for a UNIX shell like the Korn shell, you might say:
runCommand("ksh -c alias");
where "alias" is a command built into the shell. The output in this case is a list of all your shell aliases.
In the example above of obtaining a directory listing, you can use portable Java facilities to achieve the same result. For example, saying:
import java.io.File;
public class DumpFiles {
public static void main(String args[]) {
String list[] = new File(".").list();
for (int i = 0; i < list.length; i++)
System.out.println(list[i]);
}
}
|
gives you a list of all files and directories in the current directory. So using ls/dir probably doesn't make sense in most cases.
A situation where it makes sense to use Runtime.exec is one
in which you allow the user to specify an editor or word processor
(like Emacs or Vi or Word) to edit files. This is a common feature
in large applications. The application would have a configuration
file with the local path of the editor, and Runtime.exec would be
called with this path.
One tricky aspect of Runtime.exec is how it finds files. For
example, if you say:
Runtime.exec("ls");
how is the "ls" program found? Experiments with JDK 1.2.2 indicate that the PATH environment variable is searched. This is just like what happens when you execute commands with a shell. But the documentation doesn't address this point, so it pays to be careful. You can't assume that a search path has been set. It might make more sense to use Runtime.exec in a limited way as discussed above, with absolute paths specified.
There's also a variant of Runtime.exec that allows you to specify
environment strings.
Click to view Source code for this tip, or right-click to download.
— Note —
The names on the JDC mailing list are used for internal Sun Microsystems purposes only. To remove your name from the list, see Subscribe/Unsubscribe below.
— Feedback —
Comments? Send your feedback on the JDC Tech Tips to: jdc-webmaster
— Subscribe/Unsubscribe —
To subscribe to these and other SDN publications:
- Go to the Sun Developer Network - Subscriptions page,
choose the newsletters you want to subscribe to and click
"Submit".
To unsubscribe,
- Go to the Sun Developer Network -
Subscriptions page,
uncheck the appropriate checkbox, and click "Submit".
_______
1 As used on this web site, the
terms "Java
virtual machine" or "JVM" mean a virtual
machine for the Java
platform.
| ||||||||||||
