Since JDK 1.2 there has been a method in Frame (JFrame's parent) to set the icon. Its name is setIconImage().

You have to sign your applet. See the Netscape, Internet Explorer or Sun Java Plug-in documentation for details on how to do this.

There are new methods on Frame (the AWT parent of JFrame) to do this in J2SDK 1.4. See http://java.sun.com/j2se/1.4/docs/guide/awt/AWTChanges.html#zoom and http://java.sun.com/j2se/1.4/docs/guide/awt/AWTChanges.html#undecorated for details

According to Sun, the correct name is "JFC Project Swing".  Everyone else refers to it as simply "Swing".  Swing is a set of lightweight (implemented completely in Java) graphical components. It includes not only the equivalents of AWT components, but also new ones such as table and tree widgets.

Swing is a standard part of Java 2 and higher.  Swing 1.1.1 is the last version of Swing which will be compatible with JDK 1.1.

JFC stands for "Java Foundation Classes". This is the term for several capabilities included in the Java 2 Platform. (Some pieces are available for JDK 1.1.)

• Swing components
• Accessibility
• Pluggable look-and-feel
• Java 2D (JDK 1.2 only)
• Drag-and-drop (JDK 1.2 only)

There are five versions available at http://java.sun.com/products/jfc:

• Java 2 SE SDK 1.4 (New features in Swing listed here: http://java.sun.com/j2se/1.4/docs/relnotes/features.html#Swing)
• Java 2 SDK v 1.3 (Changes from 1.2.2 are listed here: http://java.sun.com/j2se/1.3/docs/guide/swing/SwingChanges.html)

The following versions have been end-of-lifed by Sun:

• Java 2 SDK v 1.2.2 (includes Swing 1.1.1)
• JFC 1.1 with Swing 1.1.1
• JFC 1.1 with Swing 1.1
• JFC 1.1 with Swing 1.0.3 (does not use the modern package names)

Websites

• Sun's Java Foundation Classes page, http://java.sun.com/products/jfc
• Sun's Java Developer Connection (JDC), at http://developer.java.sun.com
• The Swing Connection - http://theswingconnection.com
• Swing DataBank - http://java.sun.com/products/jfc/tsc/databank/databank.html
• Java Tutorial - http://www.thejavatutorial.com
• Manning Publications' Swing Forum -http://www.spindoczine.com/swingfiles/forum.html
• JavaWorld - http://www.javaworld.com
• Java Report - http://javareport.com/
• Codeguru.com Swing section - http://www.codeguru.com/java/Swing/index.shtml
• jGuru.com's Swing section - http://www.jguru.com/jguru/faq/faqpage.jsp?name=Swing

Mailing Lists

• The EOS Swing mailing lists: swing@eos.dk and advanced-swing@eos.dk
• • - To join this mailing list please write an e-mail to mailto:swing-subscribe@eos.dk or mailto:advanced-swing-subscribe@eos.dk
  • - To unsubscribe the list please write an email to mailto:swing-unsubscribe@eos.dk or mailto:advanced-swing-unsubscribe@eos.dk
  • - Archive at http://www.egroups.com/list/swing

Newsgroups

• Most Swing questions should be posted to the comp.lang.java.gui newsgroup, news:comp.lang.java.gui
• Programming philosophy questions about Swing (i.e questions about the merits of MVC) should probably be posted to comp.lang.java.programmer newsgroup, news:comp.lang.java.programmer

[Note: I haven't personally reviewed all these books.  These came from perusing Fatbrain, Amazon and reader comments].

Available now (alphabetically by author):

• Java Foundation Classes: Swing Reference. Stephen C. Drye and William C. Wake, Manning Publications, 1999.
• Java Swing.  Robert Eckstein, Marc Loy, and Dave Wood. O'Reilly & Associates, 1998.
• Graphic Java 1.2 : Mastering the JFC, Volume 2 Swing.  David Geary. Prentice Hall, 1998.
• Up to Speed with Swing.  Steve Gutz. Manning Publications (http://www.manning.com/Gutz2), 1998.
• Java Foundation Classes.  Matthew Nelson. Computing McGraw-Hill, 1998.
• Swing. Matt Robinson and Pavel Vorobiev. Electronic chapters available from http://www.manning.com/sbe, Manning, 1999.
• Pure JFC Swing.  Pantham Satyaraj, Ph. D. MacMillan Computer Publishing 1999.
• Core Java Foundation Classes (Core Series).  Kim Topley, Cary S. Horstmann, and Gary Cornell. Prentice-Hall, 1998.
• Core Swing: Advanced Programming.  Kim Topley.  Prentice Hall, September 1999.
• The JFC Swing Tutorial.  Kathy Walrath and Mary Campione. Addison-Wesley ( http://java.sun.com/docs/books/tutorial/uiswing/), 1999.
• Programming With JFC.  Scott Weiner and Stephen Asbury. John Wiley & Sons, 1998.
• John Zukowski's Definitive Guide to Swing for Java 2. John Zukowski. APress, 1999

Forthcoming:

• Graphic Java 2, Mastering the JFC: Advanced Swing. David M. Geary Paperback Vol 4 (December 2001) ISBN: 0130796689.

1.6. Can I run Swing under a browser?
Swing is not included by default in current versions of Netscape Navigator or Microsoft Internet Explorer. See the README or CHANGES.TXT files that come in the Swing distribution for an explanation of how to make Swing work with the browser. Alternatively, the Java Plugin includes Swing, and works with even the older 3.x versions of these browsers. JDK 1.2.2 is now included on all of those AOL coasters you get, too.

OS/2's version of Netscape uses the system's default Java implementation, so Swing works there.  All versions of Mozilla (including Netscape 6.0) will behave this way in the future.

1.7. What package is Swing in?
Swing has finally settled into the javax.swing package.  Swing 1.0.3 was the last version to use the old package names.

1.8. What tools support Swing and/or JFC?

• Borland.com's JBuilder (http://www.borland.com/jbuilder/) - Win32, Solaris and Linux support (pure Java version). "Foundation" edition is free.
• IBM's VisualAge for Java (http://www.software.ibm.com/ad/vajava/) - Win32, OS/2, AIX.
• Sun's Forté Community Edition (http://www.netbeans.com/ffj/community/) - pure Java, free.
• Sun's Java 2 Platform Standard Edition SDK v 1.3 (http://java.sun.com/j2se/1.3/) - Win32, Solaris, Linux.  Many ports available.
• SwingSoft SwingBuilder (http://www.swingsoft.com/swingbuilder) - pure Java.
• Symantec/BEA Visual Café for Java (http://www.visualcafe.com) - Win32.
• Tek-Tools JForge (http://www.tek-tools.com/jforge/) - pure Java.

1.9. What is Model-View-Controller? What do design patterns have to do with Swing?
Design patterns are a literary form that document tried-and-true solutions to design problems. A good starting point is the classic book Design Patterns by Gamma et al. The most famous design pattern is "Model-View-Controller" (also known as "Observer"); this pattern was popularized in Smalltalk. MVC addresses the problem of how to build software for user interfaces. It says to divide the software into three parts: the Model is the basic behavior of the system, independent of any user interface. The View is a presentation of the Model, and the Controller determines how the user interacts with the Model. The View and Controller know about the Model, but the Model is almost unaware of their existence: it merely knows that if it changes, it has to send a message to any registered listener warning it that there have been changes.

The easiest place to see this approach is in JTable. You can define a TableModel object (the Model), and tell a JTable (combined View-Controller) to observe that model. When the data changes, the JTable is notified, and it updates its display. Several Views could monitor a single table; the Model notifies them of changes, and lets the Views figure out how to update the display. (A common mistake is to write code to update the TableModel but not send any notifications. This shows up as the changes not being reflected unless you do a resize or force a repaint. Notification is part of the Model's job.  DefaultTableModel sends these notifications for you, so see its source code for examples of what to do)

There are other design patterns used in the Swing libraries. For example, the "Composite" pattern describes how to handle a containment hierarchy of objects; JComponent implements this pattern. "Decorator" describes how to compose functionality; using CompoundBorder to nest one border inside another uses this approach. Time spent studying design patterns will often help you better understand the design of Swing.

1.10 Swing performance
Many people complain about the performance of Swing.  There are some slow components in Swing, but for the most part Swing runs quite well if used properly.

According to the Swing team at JavaOne, Kestrel (Java 2 SDK 1.3) will include a significant number of performance improvements, including improving Java2D's support for common Swing operations.  Some of these changes have already made it into Swing 1.1.1 (as of beta 2).  See http://java.sun.com/products/jfc/tsc/special_report/performance/performance.html for details.

The first performance issue to look at is how Swing is being used.  Many methods in Swing are there solely to provide compatibility with the AWT components.  These methods tend to be the worst culprits for poor performance, since they hide the component's model from you.  Remember that most Swing components are designed to be used by manipulating their model directly.  The default model for the component also tends to be a bit slow, since it has no knowledge of what your application is trying to do with the component.  If you use your own custom models, you generally see a significant performance improvement.

Another trick to remember is to fill your models when they aren't associated with a component.  After a model has been associated with a component, it sends Events to the component when it is being modified (for every new item added!).  If you add the items to the model when it is not associated with a component, and then associate the model after it is filled the component only gets one Event, notifying it that the model has been added.

1.11 Swing and Threads
The Swing Connection (http://www.theswingconnection.com) has a number of good articles on this topic, the most recent being "The Last Word in Swing Threads" (http://java.sun.com/products/jfc/tsc/tech_topics/threads3/threads3.html).  A quick summary is:

• You can construct a component in a secondary thread, you just can't (for the most part) modify them from there.  Until the component has been added to another component you're OK.
• Learn how to use SwingUtilities.invokeLater().  invokeLater() is your friend.  For Windows programmers, it is similar in concept to the idea of message posting from a child thread to the main UI thread.
• You probably want to have a look at the SwingWorker class described at The Swing Connection.
• This isn't as bad a restriction as it may seem at first glance.

In Swing, top-level windows (such as JFrame or JDialog) do not have components added directly to the window. Instead, add them to the content pane like this:

        myWindow.getContentPane().add(component)

Swing components don't implement scrolling directly. Scrolling has instead been encapsulated in the JScrollPane class. To get scrollbars on a component, wrap it in a JScrollPane. Instead of:

    panel.add(component)

use

    panel.add(new JScrollPane(component));

Components that implement the Scrollable interface will interact with JScrollPane to configure the scrolling behavior. Components that don't implement Scrollable will get the default behavior supplied by JScrollPane

Look at JSplitPane, JTabbedPane, JLayeredPane, and JScrollPane. They all provide ways to let other components share space.

Use a JOptionPane. It builds in features useful in simple dialogs.

By default, a window is hidden (but not disposed of) when it is closed. This happens after all window listeners have executed. To prevent the window from closing unless the program closes it, use this code:

        frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

"Yes, but..." You can mix these components, and it's documented at http://java.sun.com/products/jfc/tsc/swingdoc-archive/mixing.html. However, if it's at all possible, you'll find it much less problematic to convert everything to Swing. (The problem is that AWT components are heavyweight, while Swing components are lightweight, and heavyweight components always appear above lightweight components; this causes difficulty for things like tabbed panes, internal frames, popup menus, etc.)

Sun has a couple of articles explaining JInternalFrame and JDesktopPane in the Swing Connection:

• "Creating MDI Programs with Swing"
• "Internalizable/Externalizable Frames"

Override the JPanel's paintComponent() method and use it to paint the image (which you should store as an ImageIcon).  For example:

public void paintComponent(java.awt.Graphics g)
{
  super.paintComponent(g);
  int width = getWidth();
  int height = getHeight();
  java.awt.Color oldColor = g.getColor();
  if (opaque)
  {
    g.setColor(getBackground());
    g.fillRect(0, 0, width, height);
  }
  if (theImage != null)
  {
    g.drawImage(theImage.getImage(), 0, 0, this);
  }
  g.setColor(oldColor);
}

Override isManagingFocus() to return true, then all key events should be sent to your JComponent. <Christian Kaufhold>

Call theComboBox.setSelectedItem(null); <Per Cederberg>

While there could be many reasons for this behavior, one possibility is that you have a JScrollPane in a GridBagLayout without a minimum size set. Try setting a reasonable value and see if your problem disappears. <Brian Sletten>

You have to call revalidate() and repaint() on the JMenuBar. JMenuBar doesn't update itself automatically.  The reason for this is so you can add or remove multiple menus together, and then update the menu bar once when you are done.

This should be added in JDK 1.4. There's an article about this new support on The Swing Connection. Using XML serialization is much more compact than using the old Object serialization, but it isn't appropriate for serializing everything. See http://java.sun.com/products/jfc/tsc/articles/persistence/index.html

The easiest way is to use the JOptionPane constructor where you supply the components that are used to build the JOptionPane. Since you create the components, you can do whatever you want to them before you pass them to the JOptionPane. The constructors to use are any of the ones that take Objects. See the JOptionPane JavaDoc for details on what kinds of Objects you can pass to these constructors.

Either subclass AbstractTableModel and implement the required three methods, or use a DefaultTableModel (which has a built-in Vector). The methods required by AbstractTableModel are very simple to implement, so subclassing is the preferred method. Using DefaultTableModel requires the expense of copying your data from its native form into the DefaultTableModel

Although JTable has the column information, it only shows the column headers when the table is put into a JScrollPane:

    panel.add(new JScrollPane(myJTable))

JTable is only the view onto the real table. To change the table, you need to work with the table model. Each model will have its own methods to do this. If you've subclassed AbstractTableModel, you'll have to create your own add/delete methods. DefaultTableModel contains methods to add/remove/reorder rows.  See the next question too.

The model needs to notify the view of changes. The AbstractTableModel provides methods to do this, with names like fireTableDataChanged() and fireTableRowsInserted(). Your method would make its change, then call the appropriate "fire" routine to notify listeners of exactly what happened, so they can go to the model and get the current state. DefaultTableModel does this automatically.

The look-and-feel is usually responsible for providing the appearance of the cells. You can install a TableCellRenderer that uses the row and column position to determine what color the cell should be.

Subclass AbstractTableModel, and have your implementation of getValueAt() check whether the cell (or row) is loaded. If so, return it; if not, load it first and then return the value.

You can provide a sorting table model as a wrapper around a base table model. When the base table changes, the sorted table will re-sort. Operations involving the row must be translated according to the sorted order. The Swing distribution package comes with an example.

By default, the columns only subdivide the space available to them. Turn off auto-resize to get horizontal scrolling.

    JTable table = ...
    table.setAutoResizeMode (JTable.AUTO_RESIZE_OFF);
    JScrollPane pane = new JScrollPane(table);

Get the rectangle for the cell, and scroll to it:

    JTable table = ...

    table.scrollRectToVisible(table.getCellRect(row,column,true));

Sometimes it's done by setting all the column widths (minimum, preferred, and maximum) to 0 pixels, but this leaves the column in the table. A better approach is to use the removeColumn() method:

    JTable table = ...
    TableColumn deletedColumn = table.getColumn("Column Title");
    table.removeColumn(deletedColumn);

It can later be added back into the table by addColumn(). This only affects what column is shown by the JTable; the model is unaffected.

A JTable is a Component, so it can have a MouseListener attached. Check the MouseEvent to see how many clicks are in the event. If it's two, you can look at theTable.rowAtPoint(event.getPoint()) to help find out what was clicked on.

You need to use these two lines of code:

table.getColumnModel().getColumn(index).setPreferredWidth(<width>);
table.sizeColumnsToFit(-1);

The sizeColumnsToFit() call is no longer needed in JDK 1.3.

If the table has AUTO-RESIZE active, you need a different sequence:

TableColumn resizingColumn = aTable.getColumnModel().getColumn(columnIndex);
aTable.getTableHeader().setResizingColumn(resizingColumn);
resizingColumn.setWidth(theNewColumnWidth);

<Ferdinand Marchl>

You have to remove it from the ColumnModel.

TableColumnModel model = table.getColumnModel();
model.removeColumn(model.getColumn(index));

- use DefaultTableModel's addColumn method. - create a new JTable model. - update your own JTable's TableModel (Since your TableModel is a subclass of AbstractTableModel (there isn't a strong reason for it not to be) you just need to call fireTableStructureChanged() when the update is complete).

Look at the Swing examples in demo/jfc/Table/TableSorter.java.  There is a MouseListener that does exactly that.

Write a custom TableCellRenderer. A TableCellRenderer returns a Component that is used to display a table cell. To use images, you would probably return either a JComponent in whose paintComponent method you paint your image, or a JLabel that has the image set as icon.

First make getValueAt() return the Icon for that cell. Then, make getClassForColumn() return ImageIcon.class (Icon.class also works as of 1.3) in your table model. - Philip Milne

Use one of these two methods: JTable.convertColumnIndexToModel(int) or JTable.convertColumnIndexToView(int).

The ability to do this is hidden pretty well. The renderer for the JTable header isn't an attribute of the JTable, it is an attribute of each TableColumn. First, you need to get the TableColumn you want to change the header renderer for. To do that, you need to get the column's name Object, which you either know from when you created the columns, or you can find it by calling getColumnName(viewIndex)(if you only know the model index, you need to convert it to the view index). Then you can call getColumn(name). Finally, you can then call setHeaderRenderer() on the TableColumn.

JTableHeader had two new methods added in JDK 1.3, getDefaultRenderer() and setDefaultRenderer(TableCellRenderer) - Philip Milne

This method will do the job:

public boolean stopCellEditing() {
    try {
        int column = table.getEditingColumn(); 
        if (column >    -1) { 
            TableCellEditor cellEditor = table.getColumnModel().getColumn(column).getCellEditor();
            if (cellEditor == null) { 
                cellEditor = table.getDefaultEditor(table.getColumnClass(column));
            } 
            if (cellEditor != null) { 
                cellEditor.stopCellEditing(); 
            } 
        } 
    } 
    catch (Exception e) { 
        return false; 
    }
    return true; 
}

- Submitted by Timothy E Troy, author unknown

Create a subclass of PlainDocument and override its insertString() and remove() methods. Inside the overridden method, only use the superclass' method to insert (or remove) the characters if they fit the criteria you are using.

The easiest way is to create a JEditorPane and call setContentType("text/html"). The JEditorPane will look for an EditorKit registered as supporting that type, and will find the HTMLEditorKit by default.

Create an instance of HTMLEditorKit directly, and then create an empty Document using the createDefaultDocument() method. The read() and write() methods can then be used to load or save the document to a stream.

It supports a subset of HTML 3.2. The parser in Swing 1.1.1beta2 is much improved.

The easiest way is to create a JEditorPane and call setContentType("text/rtf"). The JEditorPane will look for an EditorKit registered as supporting that type, and will find the RTFEditorKit by default.

Create an instance of RTFEditorKit directly, and then create an empty Document using the createDefaultDocument() method. The read() and write() methods can then be used to load or save the document to a stream.

Use a DefaultMutableTreeNode. Use setUserObject() to include your information in the node. Make sure yourObject.toString() displays the information for your node (unless you are willing to implement a custom TreeCellRenderer).

The look-and-feel is usually responsible for providing the icons in a tree. To draw your own icons for a node, implement and install a custom TreeCellRenderer.

Make a subclass of DefaultMutableTreeNode. Override getAllowsChildren() and getChildCount() to load the tree beneath each node the first time those methods are called.

Set allowsChildren to be true for all of your container nodes, and askAllowsChildren to true in the TreeModel. By default, askAllowsChildren is false, which makes the model call isLeaf() to decide how to render a node. The isLeaf() method returns true if the node doesn't have any children at the moment. So, by default all childless nodes are drawn as leaves regardless of whether they could have children.

JTree does not have a method to do this directly. You can expand the whole tree like this:

    int row = 0;
    while (row < tree.getRowCount()) {
        tree.expandRow(row);
        row++;
    }

or collapse it like this:

    int row = tree.getRowCount() - 1;
    while (row >= 0) {
        tree.collapseRow(row);
        row--;
    }

It's easy with DefaultMutableTreeNodes and a DefaultTreeModel model:

DefaultMutableTreeNode newNode = ...
model.insertNodeInto(parentNode, newNode, 0); // or whatever position

TreePath path = new TreePath(newNode.getPath());
tree.expandPath(new TreePath(parent.getPath()));
tree.setSelectionPath(path);
tree.startEditingAtPath(path);

Create an instance of UndoManager and have it listen for UndoableEditEvents from the model you want to support undo/redo. Use the information from the UndoManager to update the choices your application presents to the user. When the user chooses to perform an undo or redo, call the appropriate methods on the UndoManager.

There are two ways to do this. The quickest way is to make your model StateEditable and use the StateEdit class. The more efficient way is to create a subclass of AbstractUndoableEdit to represent the changes that can happen to the data in your model.

Conveniently, the Swing components are all accessible since JComponent provides default accessibility support. To make a Swing component fully accessible, set the accessibleName or accessibleDescription.

For components that have simple text labels, the accessibleName is by default set to the text on the component. Components such as JMenBar or JTextArea that don't have simple text labels need to have the accessibleName explicitly set.

To set the accessibleName or accessibleDescription, get the AccessibleContext for the object and use the methods it provides, as in this code fragment:

    JTextArea noteArea = new JTextArea();
    noteArea.getAccessibleContext().setAccessibleName("Notes");
    noteArea.getAccessibleContext().setAccessibleDescription(
        "The notes you want to take");

Make your component implement interface Accessible. The Accessible interface has one method, getAccessibleContext(), that returns an instance of AccessibleContext. This is an abstract class that has six methods you must implement. (Override other methods as necessary.)

For example, if your class is a custom scrolling marquee, you would override the getAccessibleText() method to return an instance of AccessibleText. It provides methods so that assistive technologies can retrieve more detailed information about the text, for example the individual words in the text.

The Metal (cross-platform) look-and-feel is the default. To get the native one, add this code early in your main() or init() routine:

    try {
        UIManager.setLookAndFeel(
            UIManager.getSystemLookAndFeelClassName());
    } catch (Exception ex_ignored) {
        // default l&f left in place
    }

No, they're only permitted on their own platform.  Sun believes there are copyright issues related to these look and feels.

There is an alternative MacOS look and feel available from http://www.ing.unitn.it/~luttero/javaonMac/ that supports a more Mac-like single menu bar along the top of the screen.

Have your component extend from JComponent (or a descendant of JComponent). Create a subclass of ComponentUI for your custom component, overriding at least the createUI() and paint() methods. To enable the new UI, override four methods of your JComponent subclass:

        public class MyComponent extends JComponent {
                public void updateUI() {
                    setUI((MyComponentUI)UIManager.getUI(this));
                }
                public void setUI(MyComponent newUI) {
                    super.setUI(newUI);
                }
                public MyComponentUI getUI() {
                    return (MyComponentUI)ui;
                }
                public String getUIClassID() {
                    return "MyComponentUI";
                }
        }

A session at JavaOne '98 described the process: http://java.sun.com/javaone/javaone98/sessions/T309/steveIndex.html

• There is a KDE look and feel available from http://members.xoom.com/znerd/java/kde_plaf/. <Patrick Ohnewein>
• There is an alternative MacOS look and feel available from http://www.ing.unitn.it/~luttero/javaonMac/ that supports a more Mac-like single menu bar along the top of the screen.
• There's a "skinnable" Look and Feel that can use GTK+ skins at http://fred.lavigne.com/.
• 3DLF (http://www-pinot.informatik.uni-kl.de/~hillenbr/3dlf/).

JavaWorld has been running a series of articles by Bill Day in its "Media Programming" column:

• "Getting started with Java 2D", http://www.javaworld.com/javaworld/jw-07-1998/jw-07-media.html
• "Antialiasing, images, and alpha compositing in Java 2D", http://www.javaworld.com/javaworld/jw-08-1998/jw-08-media.html
• "Image processing with Java 2D", http://www.javaworld.com/javaworld/jw-09-1998/jw-09-media.html

There is another introductory article, "New 2D Graphics Features", by Monica Pawlan, at the Java Developer Connection (free registration required): http://developer.javasoft.com/developer/technicalArticles/monicap/2DGraphics/Intro/Simple2D.html.

John Zukowski has published an online article, "Drag-and-Drop How To" at http://java.miningco.com/library/weekly/aa072398.htm. This article has been updated and is now at http://java.about.com/library/weekly/aa011299.htm.

Drag-and-drop was featured as a "Question of the Week" at the JDC: http://developer.javasoft.com/developer/qow/archive/1/index.html.

More recent information has appeared at: Article 1: http://www.javaworld.com/javaworld/jw-03-1999/jw-03-dragndrop.html Article 2 in upcoming august javaworld

JavaOne presentation http://industry.java.sun.com/javaone/99/event/0,1768,617,00.html

The Java DnD FAQ, http://www.rockhoppertech.com/java-drag-and-drop-faq.html <Gene De Lisa>

Apparently not at this time: bug 4165577 (http://developer.javasoft.com/developer/bugParade/bugs/4165577.html) in the JDC bug database reports problems with this combination.

John Zukowski published another article where he uses a draggable JTree: http://java.miningco.com/library/weekly/aa011299.htm.

"I used DnD with JTree in Java 2 for myself, so it is usable. But the JDC says bug 4165577 is still in progress. The problem with DnD is that nearly all components which support a SelectionListener have problems when the SelectionListener and the DragGestureRecognizer interfere with each other (am I selecting or dragging?). This applies not only to JTree but also JTable and JTextPane. The only workaround I have found is to disable the SelectionListener for DnD". <Georg Kraemer>