/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.datatransfer;import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.border.*;import java.awt.datatransfer.*;  // Clipboard, Transferable, DataFlavor, etc.import java.awt.dnd.*;import java.util.ArrayList;/** * This component can operate in two modes.  In "draw mode", it allows the user * to scribble with the mouse.  In "drag mode", it allows the user to drag * scribbles with the mouse.  Regardless of the mode, it always allows * scribbles to be dropped on it from other applications. **/public class ScribbleDragAndDrop extends JComponent    implements DragGestureListener,   // For recognizing the start of drags	       DragSourceListener,    // For processing drag source events	       DropTargetListener,    // For processing drop target events	       MouseListener,         // For processing mouse clicks	       MouseMotionListener    // For processing mouse drags{    ArrayList scribbles = new ArrayList();  // A list of Scribbles to draw    Scribble currentScribble;               // The scribble in progress    Scribble beingDragged;                  // The scribble being dragged    DragSource dragSource;                  // A central DnD object    boolean dragMode;                       // Are we dragging or scribbling?    // These are some constants we use    static final int LINEWIDTH = 3;    static final BasicStroke linestyle = new BasicStroke(LINEWIDTH);    static final Border normalBorder = new BevelBorder(BevelBorder.LOWERED);    static final Border dropBorder = new BevelBorder(BevelBorder.RAISED);    /** The constructor: set up drag-and-drop stuff */    public ScribbleDragAndDrop() {	// Give ourselves a nice default border.	// We'll change this border during drag-and-drop.	setBorder(normalBorder);	// Register listeners to handle drawing	addMouseListener(this);	addMouseMotionListener(this);	// Create a DragSource and DragGestureRecognizer to listen for drags	// The DragGestureRecognizer will notify the DragGestureListener	// when the user tries to drag an object	dragSource = DragSource.getDefaultDragSource();	dragSource.createDefaultDragGestureRecognizer(this, // What component		          DnDConstants.ACTION_COPY_OR_MOVE, // What drag types?						      this);// the listener	// Create and set up a DropTarget that will listen for drags and	// drops over this component, and will notify the DropTargetListener	DropTarget dropTarget = new DropTarget(this,   // component to monitor					       this);  // listener to notify	this.setDropTarget(dropTarget);  // Tell the component about it.    }    /**     * The component draws itself by drawing each of the Scribble objects.     **/    public void paintComponent(Graphics g) {	super.paintComponent(g);	Graphics2D g2 = (Graphics2D) g;	g2.setStroke(linestyle);   // Specify wide lines	int numScribbles = scribbles.size();	for(int i = 0; i < numScribbles; i++) {	    Scribble s = (Scribble)scribbles.get(i);	    g2.draw(s);         // Draw the scribble	}    }    public void setDragMode(boolean dragMode) {	this.dragMode = dragMode;    }    public boolean getDragMode() { return dragMode; }    /**     * This method, and the following four methods are from the MouseListener     * interface.  If we're in drawing mode, this method handles mouse down     * events and starts a new scribble.     **/    public void mousePressed(MouseEvent e) {	if (dragMode) return;	currentScribble = new Scribble();	scribbles.add(currentScribble);	currentScribble.moveto(e.getX(), e.getY());    }    public void mouseReleased(MouseEvent e) {}    public void mouseClicked(MouseEvent e) {}    public void mouseEntered(MouseEvent e) {}    public void mouseExited(MouseEvent e) {}    /**     * This method and mouseMoved() below are from the MouseMotionListener     * interface.  If we're in drawing mode, this method adds a new point     * to the current scribble and requests a redraw     **/    public void mouseDragged(MouseEvent e) {	if (dragMode) return;	currentScribble.lineto(e.getX(), e.getY());	repaint();    }    public void mouseMoved(MouseEvent e) {}    /**     * This method implements the DragGestureListener interface.  It will be     * invoked when the DragGestureRecognizer thinks that the user has      * initiated a drag.  If we're not in drawing mode, then this method will     * try to figure out which Scribble object is being dragged, and will     * initiate a drag on that object.     **/    public void dragGestureRecognized(DragGestureEvent e) {	// Don't drag if we're not in drag mode	if (!dragMode) return;	// Figure out where the drag started	MouseEvent inputEvent = (MouseEvent) e.getTriggerEvent();	int x = inputEvent.getX();	int y = inputEvent.getY();	// Figure out which scribble was clicked on, if any by creating a 	// small rectangle around the point and testing for intersection.	Rectangle r = new Rectangle (x-LINEWIDTH, y-LINEWIDTH, 				     LINEWIDTH*2, LINEWIDTH*2);	int numScribbles = scribbles.size();	for(int i =  0; i < numScribbles; i++) {  // Loop through the scribbles	    Scribble s = (Scribble) scribbles.get(i);	    if (s.intersects(r)) {  		// The user started the drag on top of this scribble, so 		// start to drag it.		// First, remember which scribble is being dragged, so we can 		// delete it later (if this is a move rather than a copy)		beingDragged = s;		// Next, create a copy that will be the one dragged		Scribble dragScribble = (Scribble) s.clone();		// Adjust the origin to the point the user clicked on.		dragScribble.translate(-x, -y);  				// Choose a cursor based on the type of drag the user initiated		Cursor cursor;		switch(e.getDragAction()) {		case DnDConstants.ACTION_COPY: 		    cursor = DragSource.DefaultCopyDrop;		    break;		case DnDConstants.ACTION_MOVE:		    cursor = DragSource.DefaultMoveDrop;		    break;		default: 		    return;   // We only support move and copys		}		// Some systems allow us to drag an image along with the 		// cursor.  If so, create an image of the scribble to drag		if (dragSource.isDragImageSupported()) {		    Rectangle scribbleBox = dragScribble.getBounds();		    Image dragImage = this.createImage(scribbleBox.width,						       scribbleBox.height);		    Graphics2D g = (Graphics2D)dragImage.getGraphics();		    g.setColor(new Color(0,0,0,0));  // transparent background		    g.fillRect(0, 0, scribbleBox.width, scribbleBox.height);		    g.setColor(Color.black);		    g.setStroke(linestyle);			g.translate(-scribbleBox.x, -scribbleBox.y);		    g.draw(dragScribble);		    Point hotspot = new Point(-scribbleBox.x, -scribbleBox.y);		    		    // Now start dragging, using the image.		    e.startDrag(cursor, dragImage, hotspot, dragScribble,this);		}		else {		    // Or start the drag without an image		    e.startDrag(cursor, dragScribble,this);		}		// After we've started dragging one scribble, stop looking		return;	    }	}    }    /**     * This method, and the four unused methods that follow it implement the     * DragSourceListener interface.  dragDropEnd() is invoked when the user     * drops the scribble she was dragging.  If the drop was successful, and     * if the user did a "move" rather than a "copy", then we delete the     * dragged scribble from the list of scribbles to draw.     **/    public void dragDropEnd(DragSourceDropEvent e) {	if (!e.getDropSuccess()) return;	int action = e.getDropAction();	if (action == DnDConstants.ACTION_MOVE) {	    scribbles.remove(beingDragged);	    beingDragged = null;	    repaint();	}    }    // These methods are also part of DragSourceListener.    // They are invoked at interesting points during the drag, and can be    // used to perform "drag over" effects, such as changing the drag cursor    // or drag image.    public void dragEnter(DragSourceDragEvent e) {}    public void dragExit(DragSourceEvent e) {}    public void dropActionChanged(DragSourceDragEvent e) {}    public void dragOver(DragSourceDragEvent e) {}    // The next five methods implement DropTargetListener    /**     * This method is invoked when the user first drags something over us.     * If we understand the data type being dragged, then call acceptDrag()     * to tell the system that we're receptive.  Also, we change our border     * as a "drag under" effect to signal that we can accept the drop.     **/    public void dragEnter(DropTargetDragEvent e) {	if (e.isDataFlavorSupported(Scribble.scribbleDataFlavor) ||	    e.isDataFlavorSupported(DataFlavor.stringFlavor)) {	    e.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE);	    this.setBorder(dropBorder);	}    }        /** The user is no longer dragging over us, so restore the border */    public void dragExit(DropTargetEvent e) { this.setBorder(normalBorder); }      /**      * This is the key method of DropTargetListener.  It is invoked when the     * user drops something on us.     **/    public void drop(DropTargetDropEvent e) {	this.setBorder(normalBorder);          // Restore the default border	// First, check whether we understand the data that was dropped.	// If we supports our data flavors, accept the drop, otherwise reject.	if (e.isDataFlavorSupported(Scribble.scribbleDataFlavor) ||	    e.isDataFlavorSupported(DataFlavor.stringFlavor)) {	    e.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);	}	else {	    e.rejectDrop();	    return;	}	// We've accepted the drop, so now we attempt to get the dropped data	// from the Transferable object.	Transferable t = e.getTransferable();  // Holds the dropped data	Scribble droppedScribble;  // This will hold the Scribble object	// First, try to get the data directly as a scribble object	try {	    droppedScribble =		(Scribble) t.getTransferData(Scribble.scribbleDataFlavor);	}	catch (Exception ex) {  // unsupported flavor, IO exception, etc.	    // If that doesn't work, try to get it as a String and parse it	    try {		String s = (String) t.getTransferData(DataFlavor.stringFlavor);		droppedScribble = Scribble.parse(s);	    }	    catch(Exception ex2) {		// If we still couldn't get the data, tell the system we failed		e.dropComplete(false);		return;	    }	}	// If we get here, we've got the Scribble object	Point p = e.getLocation();         // Where did the drop happen?	droppedScribble.translate(p.getX(), p.getY());  // Move it there	scribbles.add(droppedScribble);                 // add to display list	repaint();                                      // ask for redraw	e.dropComplete(true);                           // signal success!    }    // These are unused DropTargetListener methods    public void dragOver(DropTargetDragEvent e) {}    public void dropActionChanged(DropTargetDragEvent e) {}        /**     * The main method.  Creates a simple application using this class.  Note     * the buttons for switching between draw mode and drag mode.     **/    public static void main(String[] args) {	// Create a frame and put a scribble pane in it	JFrame frame = new JFrame("ScribbleDragAndDrop");	final ScribbleDragAndDrop scribblePane = new ScribbleDragAndDrop();	frame.getContentPane().add(scribblePane, BorderLayout.CENTER);	// Create two buttons for switching modes	JToolBar toolbar = new JToolBar();	ButtonGroup group = new ButtonGroup();	JToggleButton draw = new JToggleButton("Draw");	JToggleButton drag = new JToggleButton("Drag");	draw.addActionListener(new ActionListener() {		public void actionPerformed(ActionEvent e) {		    scribblePane.setDragMode(false);		}	    });	drag.addActionListener(new ActionListener() {		public void actionPerformed(ActionEvent e) {		    scribblePane.setDragMode(true);		}	    });	group.add(draw); group.add(drag);	toolbar.add(draw); toolbar.add(drag);	frame.getContentPane().add(toolbar, BorderLayout.NORTH);	// Start off in drawing mode	draw.setSelected(true);	scribblePane.setDragMode(false);	// Pop up the window	frame.setSize(400, 400);	frame.setVisible(true);    }}