te DndFlavor() throws ClassNotFoundException {
       super(DndContent.class, "Content");
       //super(javaJVMLocalObjectMimeType+";class="+DndContent.class.getName());
    }

    private static final DndFlavor singleton;

    static {
        singleton = createSingleton();
    }
    private static DndFlavor createSingleton() {
        DndFlavor result = null;
        try {
            result = new DndFlavor();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return result;
    }

    public static DndFlavor getFlavor() {
        return singleton;
    }
}

class DndContent {
    private Object _object;

    public DndContent(Object object) {
        _object = object;
    }

    public Object getContent() {
        return _object;
    }

    public String toString() {
        return _object.toString();
    }
}

// this is the class that contains results for drag-n-drop

class ObjectTransferable implements Transferable {

    private static final DataFlavor[] flavors = {
        DndFlavor.getFlavor()
    };
    private DndContent _content;

    ObjectTransferable(Object object) {
        _content = new DndContent(object);
        showFlavor("CatalogTransferable", flavors[0]);
    }

    static void showFlavor(String title, DataFlavor flavor) {
        System.err.println(title+": flavor="+flavor.getHumanPresentableName()+" mime="+flavor.getMimeType());
    }

    // return a copy of the DataFlavor array
    public DataFlavor[] getTransferDataFlavors() {
        //showFlavor("getTransferDataFlavors", flavors[0]);
        //new Throwable().printStackTrace();
        return (DataFlavor[])flavors.clone();
    }

    // returns true only if flavor is Content
    public boolean isDataFlavorSupported(DataFlavor flavor) {
        //showFlavor("isDataFlavorSupported ("+flavor.equals(DndFlavor.getFlavor())+")", flavor);
        return flavor.equals(DndFlavor.getFlavor());
    }

    //
    public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
        //showFlavor("getTransferData", flavor);
        if (isDataFlavorSupported(flavor)) {
            return _content;
        }
        throw new UnsupportedFlavorException(flavor);
    }

    public String toString() {
        return "["+flavors[0].getMimeType()+"]";
    }
}

ingrid.yao@Eng 2001-06-21

java version "1.4.0-beta"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.0-beta-b65)
Java HotSpot(TM) Client VM (build 1.4.0-beta-b65, mixed mode)

Attached test problem works when I on either JDK 1.3.1 or JDK 1.4
on Linux (RedHat 7.0) as well as Solaris 2.7. It fails on Windows 2000,
both 1.3.1 and 1.4.

Reproduce steps:
-------------------
  o compile and run the attached application
  o click and drag on the component labeled "DRAG ME"
  o drop on the component labeled "drop here:"
  o you should see "text to be dragged" display in JTextField

On windows, the initial screen remains unchanged after the drag operation.


Test program
--------------
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;

public class TestDnD extends javax.swing.JFrame {
    TestDrop theDrop;
    public TestDnD() {
        setSize(550,200);
        getContentPane().setLayout(new java.awt.BorderLayout(5,5));
        theDrop = new TestDrop();
        getContentPane().add(theDrop, java.awt.BorderLayout.CENTER);
        javax.swing.JPanel p = new javax.swing.JPanel(false);
        javax.swing.JTextField f = new javax.swing.JTextField("text to be dragged");
        p.add(new TestDrag(f));
        p.add(f);
        javax.swing.JButton b1 = new javax.swing.JButton("ADD MOUSE");
        p.add(b1);
        javax.swing.JButton b2 = new javax.swing.JButton("ADD CUSTOM CURSOR");
        p.add(b2);
        getContentPane().add(p, java.awt.BorderLayout.SOUTH);
        addWindowListener(
            new java.awt.event.WindowAdapter() {
                public void windowClosing(java.awt.event.WindowEvent e) {
                    super.windowClosing(e);
                    TestDnD.this.setVisible(false);
                    System.exit(0);
                }
            }
        );
        b1.addActionListener(
            new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    System.out.println("action performed -> mouse listener installed.");
                    theDrop.addMouseListener(
                        new java.awt.event.MouseAdapter() {
                            public void mousePressed(java.awt.event.MouseEvent e) {
                                theDrop.setText(e.toString());
                            }
                        }
                    );
                }
            }
        );
        b2.addActionListener(
            new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    System.out.println("action performed -> custom cursor installed.");
                          java.awt.Toolkit tk = java.awt.Toolkit.getDefaultToolkit();
                          theDrop.setCursor(tk.createCustomCursor(tk.getImage(getClass().getResource("/pan_cur.gif")), new java.awt.Point(6,2), "Pan"));
                }
            }
        );

    }

    public static void main(String args[]) {
        new TestDnD().setVisible(true);
    }
}

// sample drag source component
class TestDrag extends javax.swing.JComponent {
    javax.swing.JTextField theField;
    TestDrag(javax.swing.JTextField f) {
        theField = f;
        setPreferredSize(f.getPreferredSize());
        new TestDragSource(this);
    }
    String getText() {
        return theField.getText();
    }
    public void paintComponent(java.awt.Graphics g) {
        super.paintComponent(g);
        g.setColor(java.awt.Color.pink);
        g.fill3DRect(0,0,getWidth(),getHeight(),true);
        g.setColor(java.awt.Color.black);
        java.awt.FontMetrics fm = getFontMetrics(getFont());
        g.drawString("DRAG ME",2,2+fm.getMaxAscent());
    }
}

class TestDragSource implements java.awt.dnd.DragSourceListener, java.awt.dnd.DragGestureListener {


    TestDragSource(TestDrag t) {
        field = t;
        java.awt.dnd.DragSource dragSource = java.awt.dnd.DragSource.getDefaultDragSource();
        dragSource.createDefaultDragGestureRecognizer(t, java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE, this);
    }


    public void dragGestureRecognized(java.awt.dnd.DragGestureEvent e) {
        String text = field.getText().trim();
        if (text == null) return;
        System.out.println("dragGestureRecognized: text=" + text+" flavormap contains:");
        java.awt.datatransfer.FlavorMap flavors = e.getDragSource().getFlavorMap();
        java.util.Map map = flavors.getNativesForFlavors(null);
        java.util.Iterator iterator = map.keySet().iterator();
        // 1.3.x bug : returned value differs from javadoc (appears fixed at 1.4)
        String version = System.getProperty("java.version");
        boolean is14 = version.startsWith("1.4");
        while(iterator.hasNext()) {
            if (is14) {
                java.awt.datatransfer.DataFlavor flavor = (java.awt.datatransfer.DataFlavor)iterator.next();
                System.out.println(" "+flavor.getMimeType());
            }
            else {
                String flavor = (String)iterator.next();
                System.out.println(" "+flavor);
            }
        }

        ObjectTransferable td = new ObjectTransferable (field);


        e.startDrag(java.awt.dnd.DragSource.DefaultCopyDrop, td, this);
    }


    public void dragDropEnd (java.awt.dnd.DragSourceDropEvent e) {
        System.out.println("DragSource: dragDropEnd");
    }

    public void dragEnter (java.awt.dnd.DragSourceDragEvent e) {
        java.awt.dnd.DragSourceContext context = (java.awt.dnd.DragSourceContext)e.getSource();
        Transferable transferable = context.getTransferable();
        System.out.println("DragSource.dragEnter: "+transferable);
    }

    public void dragExit (java.awt.dnd.DragSourceEvent e) {
        //System.out.println("DragSource: dragExit");
    }

    public void dragOver (java.awt.dnd.DragSourceDragEvent e) {
        //System.out.println("DragSource: dragOver");
    }

    public void dropActionChanged (java.awt.dnd.DragSourceDragEvent e) {
        System.out.println("DragSource.dropActionChanged: "+e);
    }

    private TestDrag field;
}

// sample drop target component
class TestDrop extends TextDisplay {
    private Layers _layers;
    private EventLayer _events;
    private javax.swing.JScrollPane _scroll;
    private TextDisplay _textDisplay;
    private TopPanel _topPanel;

    // set these variables to true when you want to test the following:
    // UseLayeredPane - TestDrop contains a LayeredPane that contains the ScrollPane stuff
    // the drop target is the EventLayer on top of the JLayeredPane
    // UseScrollPane - TestDrop contains a ScrollPane that contains the TextDisplay stuff
    // the drop target is the TextDisplay
    // UseContainer - TestDrop is a simple Container that contains a TextDisplay
    // the drop target is the TextDisplay
    // {none of the above} - TestDrop *is* a TextDisplay and *is* the drop target
    private final boolean UseLayeredPane = false;
    private final boolean UseScrollPane = UseLayeredPane || false;
    private final boolean UseContainer = UseScrollPane || false;

    TestDrop() {
        if (UseContainer) {
            this.setLayout(new java.awt.BorderLayout());

            if (UseLayeredPane) {
                _layers = new Layers();
                this.add(_layers,java.awt.BorderLayout.CENTER);

                _events = new EventLayer();
                _layers.add(_events,javax.swing.JLayeredPane.DEFAULT_LAYER);
            }

            if (UseScrollPane) {
                _scroll = new javax.swing.JScrollPane();
                _scroll.setHorizontalScrollBarPolicy(javax.swing.JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
                if (UseLayeredPane) {
                    _layers.add(_scroll,javax.swing.JLayeredPane.FRAME_CONTENT_LAYER);
                }
                else {
                    this.add(_scroll,java.awt.BorderLayout.CENTER);
                }
                _topPanel = new TopPanel();
                _scroll.setViewportView(_topPanel);
                _topPanel.setScrollPane(_scroll);
            }

            _textDisplay = new TextDisplay();
            if (UseScrollPane) {
                _topPanel.add(_textDisplay);
            }
            else {
                this.add(_textDisplay,java.awt.BorderLayout.CENTER);
            }

            if (UseLayeredPane) {
                _events.setDropTarget(new TestDropTarget(this));
            }
            else {
                _textDisplay.setDropTarget(new TestDropTarget(this));
            }
            setText("Container");
        }
        else {
            setDropTarget(new TestDropTarget(this));
            setText("TextDisplay");
        }
    }
    void setText(String text) {
        if (UseContainer) {
            _textDisplay.setText(text);
            if (UseLayeredPane) {
                _events.repaint();
            }
        }
        else {
            super.setText(text);
        }
    }
}

class EventLayer extends javax.swing.JComponent {
    public void paintComponent(java.awt.Graphics g) {
        super.paintComponent(g);
        //java.awt.FontMetrics fm = getFontMetrics(getFont());
        g.setColor(java.awt.Color.red);
        g.drawString("events",2,getHeight()-2);
    }
}

class Layers extends javax.swing.JLayeredPane {
    public void doLayout() {
        int n = getComponentCount();
        int w = getWidth();
        int h = getHeight();
        for (int i = 0; i < n; i++) {
            java.awt.Component c = getComponent(i);
            if (c.isVisible()) {
                c.setSize(w,h);
                c.doLayout();
            }
        }
    }
}

class TopPanel extends javax.swing.JComponent {
    private javax.swing.JScrollPane _scroll;
    TopPanel() {
        setBackground(java.awt.Color.lightGray);
        //this.setOpaque(true);
    }
    void setScrollPane(javax.swing.JScrollPane scroll) {
        _scroll = scroll;
    }
    javax.swing.JScrollPane getScrollPane() {
        return _scroll;
    }
    public void doLayout() {
        java.awt.Dimension e = getScrollPane().getViewport().getExtentSize();
        int width = e.width; // adjust width depending upon location within the Legend hierarchy
        int n = getComponentCount();
        int y = 0;
        for (int i = 0; i < n; i++) {
            java.awt.Component c = getComponent(i);
            if (c.isVisible()) {
                c.doLayout();
                java.awt.Dimension d = c.getPreferredSize();
                c.setSize(d.width, d.height);
                c.setLocation(0,y);
                y += d.height;
            }
        }
//System.out.println("LegendPanel.doLayout: "+getSize());
    }
    public java.awt.Dimension getPreferredSize() {
        int n = getComponentCount();
        int y = 0;
        for (int i = 0; i < n; i++) {
            java.awt.Component c = getComponent(i);
            if (c.isVisible()) {
                java.awt.Dimension d = c.getPreferredSize();
                y += d.height;
            }
        }
        //_height = y;
        //System.out.println("LegendPanel.getPreferredSize(): "+_width+","+y);
        return new java.awt.Dimension(400,y);
    }
    public java.awt.Dimension getMinimumSize() {
        return getPreferredSize();
    }
}

class TextDisplay extends javax.swing.JComponent {
    TextDisplay() {
        setBackground(java.awt.Color.pink);
        //this.setOpaque(true);
    }

    private String theText = "";
    void setText(String text) {
        theText = text;
        repaint();
    }
    public java.awt.Dimension getPreferredSize() {
        return new java.awt.Dimension(400,100);
    }

    /**
    * Paints the map image and the viewport frame on top.
    * @see java.awt.Container#paint
    public void paint(java.awt.Graphics g) {
    }
    */
    public void paintComponent(java.awt.Graphics g) {
        super.paintComponent(g);
        g.setColor(getBackground());
        g.fillRect(0,0,getWidth(),getHeight());
        java.awt.FontMetrics fm = getFontMetrics(getFont());
        g.setColor(java.awt.Color.black);
        g.drawString("drop here:",2,2+fm.getMaxAscent());
        g.drawString(theText,5,5+2*fm.getMaxAscent()+fm.getMaxDescent());
    }
}

class TestDropTarget extends java.awt.dnd.DropTarget {


    public TestDropTarget(TestDrop om) {
        theTarget = om;
    }

    public void dragEnter (java.awt.dnd.DropTargetDragEvent e) {
        System.out.print("DropTarget.dragEnter: ");
        java.awt.datatransfer.DataFlavor[] flavors = e.getCurrentDataFlavors();
        System.out.print(" flavors=("+flavors.length+")");
        for (int i = 0; i < flavors.length; i++) {
            System.out.print(" "+flavors[i].getMimeType());
        }
        System.out.println();
        e.acceptDrag(java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE);
    }


    public void drop (java.awt.dnd.DropTargetDropEvent e) {
        System.out.println("DropTarget.drop: "+e);

        java.awt.datatransfer.Transferable tr = e.getTransferable();

        try {
            if (e.isDataFlavorSupported (DndFlavor.getFlavor())) {
                e.acceptDrop (java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE);
                //com.esri.data.Dataset dataset = (com.esri.data.Dataset) transferable.getTransferData(com.esri.ae.cat.TransferableDataset.TransferableDatasetFlavor);
                System.out.println("dropped text is " + tr.getTransferData(DndFlavor.getFlavor()));
                DndContent dragContent = (DndContent) tr.getTransferData(DndFlavor.getFlavor());
                TestDrag dragObject = (TestDrag)dragContent.getContent();
                String text = dragObject.getText();
                theTarget.setText(text);
                e.dropComplete(true);
            } else {
                System.out.println ("Rejected");
                e.rejectDrop();
            }
        } catch (java.io.IOException io) {
            io.printStackTrace();
            e.dropComplete(false);
            return;
        } catch (java.awt.datatransfer.UnsupportedFlavorException ufe) {
            ufe.printStackTrace();
            e.dropComplete(false);
            return;
        }

    }


    /* */
    public void dragExit (java.awt.dnd.DropTargetEvent e) {
        System.out.println("DropTarget.dragExit");
    }

    public void dragOver (java.awt.dnd.DropTargetDragEvent e) {
        //System.out.println("dragOver");
    }

    public void dropActionChanged (java.awt.dnd.DropTargetDragEvent e) {
        System.out.println("DropTarget.dropActionChanged");
    }
    /**/

    private TestDrop theTarget;

}


// defines the DataFlavor that can be obtained by drag-and-drop from the Catalog

class DndFlavor extends DataFlavor {
    priva