Name: vi73552 Date: 03/09/99


The attached test program creates a MDI application in a JFrame.
A desktopPane is created and populated with two JInternalFrames:
"Drag Sources" and "Drop Target". "Drag Sources" contains 5
draggable JLabels, implementing DragSourceListener,
DragGestureListener, and Transferable. "Drop Target" contains a
droppable JPanel that implements DropTargetListener. Follow
the following steps to disable drag and drop on the desktopPane:

1: Start the application "$java Desktop"
2: Drag "Draggable Label 1" to Drop Target. (This works)
3: Now select the title bar of the "Drop Target" JInternal Frame,
   to make it the active frame with focus.
4: Now select the title bar of the "Drag Sources" JInternal Frame,
   to make it the active frame with focue.
5: Now attempt to drag another label from "Drag Sources" to
   "Drop Target". The drop functionality is no longer functional.

The "Drop Target" DropTargetListener no longer receives DragEnter
messages, the cursor continues to show a nodrop status.

My actual application involves drop and drag between two JTrees
in separate JInternalFrames. The test program below isolates the
problems that I have run into.

Any assistance with this issue would be greatly appreciated.

Regards,
Jim Anzaldi

Now the Program modified slightly to and MDI application
from "JFC Unleashed - Michael Foley and Mark McCulley":

/* Desktop.java
 *
 * Illustrates drag and drop of Java object
 * between two frame windows in same Java VM.
 */

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.dnd.*;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.DataFlavor;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;

/* App class
 */
public class Desktop extends JFrame {

public Desktop (String s)
{
JDesktopPane desktopPane = new JDesktopPane();
        desktopPane.setForeground(Color.black);
        desktopPane.setBackground(Color.lightGray);
getContentPane().add(desktopPane, BorderLayout.CENTER);
        setSize(800, 400);

        addWindowListener(new WindowAdapter() {
             public void windowClosing(WindowEvent e) {System.exit(0);}
        });

// create two frame windows
        JInternalFrame sourceFrame = new JInternalFrame("Drag Sources");
        JInternalFrame targetFrame = new JInternalFrame("Drop Target");

// create panels for each window
        JPanel sourcePanel = new SourcePanel();
        JPanel targetPanel = new TargetPanel();
        
        // add panels to content panes
        sourceFrame.getContentPane().add(sourcePanel);
        targetFrame.getContentPane().add(targetPanel);

desktopPane.add(sourceFrame);
desktopPane.add(targetFrame);

// set initial frame size and make visible
        sourceFrame.setSize (300, 200);
        targetFrame.setSize (300, 200);
        targetFrame.setLocation(sourceFrame.getX()
                              + sourceFrame.getWidth(),
                                sourceFrame.getY());
}

    // Main entry point
    public static void main(String s[])
{
Desktop desktop = new Desktop("TEST");

        desktop.show();
}
}

/* App panel class for source window
 */
class SourcePanel extends JPanel {
    // Constructor
    public SourcePanel() {
        super();
        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));

        // add some drag source components
        add(new DraggableLabel("Draggable Label 1"));
        add(new DraggableLabel("Draggable Label 2"));
        add(new DraggableLabel("Draggable Label 3"));
        add(new DraggableLabel("Draggable Label 4"));
        add(new DraggableLabel("Draggable Label 5"));
    }
}

/* App panel class for target window
 */
class TargetPanel extends JPanel {
    public TargetPanel() {
        super();
        setLayout(new BorderLayout());

        // add a drop target component
        DroppablePanel dropPanel = new DroppablePanel();
        dropPanel.setLayout(new BoxLayout(dropPanel, BoxLayout.Y_AXIS));
        add(dropPanel);
    }
}

/* Drag source component implementation
 */
class DraggableLabel extends JLabel implements DragSourceListener,
                                               DragGestureListener,
                                               Transferable {
    // Constructor
    public DraggableLabel(String text) {
        super(text);

        // create a drag source
        DragSource ds = DragSource.getDefaultDragSource();
        
        // create a drag gesture recognizer
DragGestureRecognizer dgr = ds.createDefaultDragGestureRecognizer(
            this, // component
            DnDConstants.ACTION_COPY_OR_MOVE, // actions
            this); // drag gesture listener
    }

    // DragGestureListener interface implementation
    public void dragGestureRecognized(DragGestureEvent event) {
        event.startDrag(null, // drag cursor
                        this, // transferable object
                        this); // drag source listener
    }
    
    // Transferable interface implementation
    public Object getTransferData(DataFlavor flavor) {
        // if we support requested data flavor,
        // return this object as transfer data
        if(flavor.equals(MyFlavors.draggableLabelFlavor)) {
            return(this);
        }
        else return null;
    }

    public DataFlavor[] getTransferDataFlavors() {
        // return suppported data flavors
        DataFlavor[] flavors = { MyFlavors.draggableLabelFlavor };
        return flavors;
    }

    public boolean isDataFlavorSupported(DataFlavor flavor) {
        if(flavor.equals(MyFlavors.draggableLabelFlavor))
            return true;
        else
            return false;
    }

    // DragSourceListener interface implementation
    public void dragDropEnd(DragSourceDropEvent dsde) { }
    public void dragEnter(DragSourceDragEvent dsde) { }
    public void dragExit(DragSourceEvent dse) { }
    public void dragOver(DragSourceDragEvent dsde) { }
    public void dropActionChanged(DragSourceDragEvent dsde) { }
}

/* Drop target component implementation
 */
class DroppablePanel extends JPanel implements DropTargetListener {
    // background colors for normal and under drag states
    private Color bkgNormal = Color.lightGray;
    private Color bkgUnderDrag = Color.yellow;

    // Constructor
    public DroppablePanel() {
        super();

        // create a drop target for this component
        DropTarget dt = new DropTarget(this, this);
    }

    //
    // DropTargetListener interface implementation
    //
    public void dragEnter(DropTargetDragEvent dtde) {

System.out.println("DROP ENTER");

if(isValidDragDrop(dtde.getDropAction(),
                           dtde.getCurrentDataFlavors())) {
            // accept drag
            dtde.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE);

            // change background color to visually indicate
            // that drop target is under drag
            showUnderDrag(true);
        }
        else {
            dtde.rejectDrag();
        }
    }

    public void dragExit(DropTargetEvent dte) {
        // drop target no longer under drag, restore background color
        showUnderDrag(false);
    }

    public void dragOver(DropTargetDragEvent dtde) { }

    public void drop(DropTargetDropEvent dtde) {
        // validate drop action and data flavors
if(isValidDragDrop(dtde.getDropAction(),
                           dtde.getCurrentDataFlavors())) {
            dtde.acceptDrop(dtde.getDropAction());

            try {
                // get transfer data (DraggableLabel object)
                Transferable xfer = dtde.getTransferable();
Object obj = xfer.getTransferData(MyFlavors.draggableLabelFlavor);

                // add object to panel and revalidate
                if(obj instanceof JComponent) {
                    add((JComponent)obj);
                    revalidate();
                }
                // notify system that dnd completed successfully
                dtde.dropComplete(true);
            }
            catch(Exception exc) {
                System.err.println(exc);
                exc.printStackTrace();
                dtde.dropComplete(false);
            }
            
        }
        else {
            // invalid drop action or data flavor, reject drop
            dtde.rejectDrop();
        }
        
        // drop operation complete, restore background color
        showUnderDrag(false);
    }

    public void dropActionChanged(DropTargetDragEvent dtde) { }

    //
    // Private helper methods
    //

    // validates given drop action and data flavor
private boolean isValidDragDrop(int dropAction,
                                    DataFlavor flavors []) {
        if((dropAction & DnDConstants.ACTION_COPY_OR_MOVE) != 0) {
            for(int i=0; i<flavors.length; i++) {
                if(flavors[i].getPrimaryType().equals("application")
&& flavors[i].getSubType().equals(
                     "x-java-serialized-object")) {
                    return true;
                }
            }
        }
        return false;
    }

    // changes background color to indicate that
    // component is under drag operation
    private void showUnderDrag(boolean underDrag) {
        if(underDrag) setBackground(bkgUnderDrag);
        else setBackground(bkgNormal);

        paintImmediately(0, 0, getWidth(), getHeight());
    }
}

/* Class containing predefined DataFlavor objects
 */
class MyFlavors extends Object {
    static public DataFlavor draggableLabelFlavor
        = createFlavor("DraggableLabel", "draggable Label object");

    // creates a DataFlavor object from
    // representation class name and description
    static private DataFlavor createFlavor(String className,
                                           String description) {
        Class cls;
        // create class from class name
        try {
            cls = Class.forName(className);
        }
        catch(Exception exc) {
            System.err.println(exc);
            cls = null;
        }
        // create and return data flavor
        return new DataFlavor(cls, description);
    }
}
(Review ID: 55220)
======================================================================