لطفا منتظر باشید ...
14.6 Custom Data Transfer
Example 14-5 is a custom Swing component named
TransferableScribblePane. It allows the user to
scribble with the mouse and to select one scribble at a time. It
defines cut( ), copy( ), and
paste( ) methods that operate on the selected
line, and also allows the selected line to be dragged and dropped
within the component or into another instance of the component. The
scribbles are transferred using the
TransferablePolyLine class defined in Example 14-4, of course.This example does not use the high-level Swing
TransferHandler class, but instead relies on the
underlying data transfer and drag-and-drop architecture of
java.awt.datatransfer and
java.awt.dnd. The code for performing drag-and-drop is
substantially more complex than the code for cut-and-paste. This is
because the asynchronous drag-and-drop model requires a number of
distinct event listeners and their corresponding event objects. The
key interfaces are DragGestureListener, which
triggers a new drag, and DragSourceListener and
DropTargetListener, which notify the source of a
drag and the target of a drop of important events that occur during
the drag-and-drop process. The example implements all three
interfaces as anonymous inner classes. When studying the example, pay
particular attention to the dragGestureRecognized(
) method of the DragSourceListener and
the drop( ) method of the
DropTargetListener. The first is where the drag is
initiated, and the second is where the data transfer actually
transpires.To test this component, display two copies of it using the
ShowBean program. Draw a line with the mouse, then
select the line by shift-clicking on it. Next, drag and drop the
selected line while holding down the Shift or Ctrl
keys. Also, use the Commands menu of
ShowBean to invoke the cut( ),
copy( ), and paste( ) methods.
Example 14-5. TransferableScribblePane.java
package je3.datatransfer;
import java.awt.*; // Graphics, Rectangle, Stroke, etc.
import java.awt.datatransfer.*; // Transferable, DataFlavor
import java.awt.dnd.*; // Drag-and-drop listeners and events
import java.awt.event.*; // Mouse events
import javax.swing.*; // JComponent
import javax.swing.border.*; // LineBorder and BevelBorder
import java.util.*; // ArrayList, etc.
import java.util.List;
// Explicit import to disambiguate from java.awt.List
import je3.graphics.PolyLine; // The Shape of scribbles
/**
* This rewrite of ScribblePane allows individual PolyLine lines to be
* selected, cut, copied, pasted, dragged, and dropped.
*/
public class TransferableScribblePane extends JComponent {
List lines; // The PolyLines that comprise this scribble
PolyLine currentLine; // The line currently being drawn
PolyLine selectedLine; // The line that is current selected
boolean canDragImage; // Can we drag an image of the line?
// Lines are 3 pixels wide, and the selected line is drawn dashed
static Stroke stroke = new BasicStroke(3.0f);
static Stroke selectedStroke = new BasicStroke(3, BasicStroke.CAP_BUTT,
BasicStroke.JOIN_ROUND, 0f,
new float[ ] { 3f, 3f, },0f);
// Different borders indicate receptivity to drops
static Border normalBorder = new LineBorder(Color.black, 3);
static Border canDropBorder = new BevelBorder(BevelBorder.LOWERED);
// The constructor method
public TransferableScribblePane( ) {
setPreferredSize(new Dimension(450,200)); // We need a default size
setBorder(normalBorder); // and a border.
lines = new ArrayList( ); // Start with an empty list of lines
// Register interest in mouse button and mouse motion events.
enableEvents(AWTEvent.MOUSE_EVENT_MASK |
AWTEvent.MOUSE_MOTION_EVENT_MASK);
// Enable drag-and-drop by specifying a listener that will be
// notified when a drag begins. dragGestureListener is defined later.
DragSource dragSource = DragSource.getDefaultDragSource( );
dragSource.createDefaultDragGestureRecognizer(this,
DnDConstants.ACTION_COPY_OR_MOVE,
dragGestureListener);
// Enable drops on this component by registering a listener to
// be notified when something is dragged or dropped over us.
this.setDropTarget(new DropTarget(this, dropTargetListener));
// Check whether the system allows us to drag an image of the line
canDragImage = dragSource.isDragImageSupported( );
}
/** We override this method to draw ourselves. */
public void paintComponent(Graphics g) {
// Let the superclass do its painting first
super.paintComponent(g);
// Make a copy of the Graphics context so we can modify it
Graphics2D g2 = (Graphics2D) (g.create( ));
// Our superclass doesn't paint the background, so do this ourselves.
g2.setColor(getBackground( ));
g2.fillRect(0, 0, getWidth( ), getHeight( ));
// Set the line width and color to use for the foreground
g2.setStroke(stroke);
g2.setColor(this.getForeground( ));
// Now loop through the PolyLine shapes and draw them all
int numlines = lines.size( );
for(int i = 0; i < numlines; i++) {
PolyLine line = (PolyLine)lines.get(i);
if (line == selectedLine) { // If it is the selected line
g2.setStroke(selectedStroke); // Set dash pattern
g2.draw(line); // Draw the line
g2.setStroke(stroke); // Revert to solid lines
}
else g2.draw(line); // Otherwise just draw the line
}
}
/**
* This method is called on mouse button events. It begins a new line
* or tries to select an existing line.
*/
public void processMouseEvent(MouseEvent e) {
if (e.getButton( ) == MouseEvent.BUTTON1) { // Left mouse button
if (e.getID( ) == MouseEvent.MOUSE_PRESSED) { // Pressed down
if (e.isShiftDown( )) { // with Shift key
// If the shift key is down, try to select a line
int x = e.getX( );
int y = e.getY( );
// Loop through the lines, checking to see if we hit one
PolyLine selection = null;
int numlines = lines.size( );
for(int i = 0; i < numlines; i++) {
PolyLine line = (PolyLine)lines.get(i);
if (line.intersects(x-2, y-2, 4, 4)) {
selection = line;
e.consume( );
break;
}
}
// If we found an intersecting line, save it and repaint
if (selection != selectedLine) { // If selection changed
selectedLine = selection; // remember which is selected
repaint( ); // will make selection dashed
}
}
else if (!e.isControlDown( )) { // no shift key or ctrl key
// Start a new line on mouse down without shift or ctrl
currentLine = new PolyLine(e.getX( ), e.getY( ));
lines.add(currentLine);
e.consume( );
}
}
else if (e.getID( ) == MouseEvent.MOUSE_RELEASED) {// Left Button Up
// End the line on mouse up
if (currentLine != null) {
currentLine = null;
e.consume( );
}
}
}
// The superclass method dispatches to registered event listeners
super.processMouseEvent(e);
}
/**
* This method is called for mouse motion events.
* We don't have to detect gestures that initiate a drag in this method.
* That is the job of the DragGestureRecognizer we created in the
* constructor: it will notify the DragGestureListener defined below.
*/
public void processMouseMotionEvent(MouseEvent e) {
if (e.getID( ) == MouseEvent.MOUSE_DRAGGED && // If we're dragging
currentLine != null) { // and a line exists
currentLine.addSegment(e.getX( ), e.getY( )); // Add a line segment
e.consume( ); // Eat the event
repaint( ); // Redisplay all lines
}
super.processMouseMotionEvent(e); // Invoke any listeners
}
/** Copy the selected line to the clipboard, then delete it */
public void cut( ) {
if (selectedLine == null) return; // Only works if a line is selected
copy( ); // Do a Copy operation...
lines.remove(selectedLine); // and then erase the selected line
selectedLine = null;
repaint( ); // Repaint because a line was removed
}
/** Copy the selected line to the clipboard */
public void copy( ) {
if (selectedLine == null) return; // Only works if a line is selected
// Get the system Clipboard object.
Clipboard c = this.getToolkit( ).getSystemClipboard( );
// Wrap the selected line in a TransferablePolyLine object
// and pass it to the clipboard, with an object to receive notification
// when some other application takes ownership of the clipboard
c.setContents(new TransferablePolyLine((PolyLine)selectedLine.clone( )),
new ClipboardOwner( ) {
public void lostOwnership(Clipboard c,Transferable t){
// This method is called when something else
// is copied to the clipboard. We could use it
// to deselect the selected line, if we wanted.
}
});
}
/** Get a PolyLine from the clipboard, if one exists, and display it */
public void paste( ) {
// Get the system Clipboard and ask for its Transferable contents
Clipboard c = this.getToolkit( ).getSystemClipboard( );
Transferable t = c.getContents(this);
// See if we can extract a PolyLine from the Transferable object
PolyLine line;
try {
line = (PolyLine)t.getTransferData(TransferablePolyLine.FLAVOR);
}
catch(Exception e) { // UnsupportedFlavorException or IOException
// If we get here, the clipboard doesn't hold a PolyLine we can use
getToolkit( ).beep( ); // So beep to indicate the error
return;
}
lines.add(line); // We got a line from the clipboard, so add it to list
repaint( ); // And repaint to make the line appear
}
/** Erase all lines and repaint. */
public void clear( ) {
lines.clear( );
repaint( );
}
/**
* This DragGestureListener is notified when the user initiates a drag.
* We passed it to the DragGestureRecognizer we
created in the constructor.
*/
public DragGestureListener dragGestureListener =
new DragGestureListener( ){
public void dragGestureRecognized(DragGestureEvent e) {
// Don't start a drag if there isn't a selected line
if (selectedLine == null) return;
// Find out where the drag began
MouseEvent trigger = (MouseEvent)e.getTriggerEvent( );
int x = trigger.getX( );
int y = trigger.getY( );
// Don't do anything if the drag was not near the selected line
if (!selectedLine.intersects(x-4, y-4, 8, 8)) return;
// Make a copy of the selected line, adjust the copy so that
// the point under the mouse is (0,0), and wrap the copy in a
// Tranferable wrapper.
PolyLine copy = (PolyLine)selectedLine.clone( );
copy.translate(-x, -y);
Transferable t = new TransferablePolyLine(copy);
// If the system allows custom images to be dragged, make
// an image of the line on a transparent background
Image dragImage = null;
Point hotspot = null;
if (canDragImage) {
Rectangle box = copy.getBounds( );
dragImage = createImage(box.width, box.height);
Graphics2D g = (Graphics2D)dragImage.getGraphics( );
g.setColor(new Color(0,0,0,0)); // transparent bg
g.fillRect(0, 0, box.width, box.height);
g.setColor(getForeground( ));
g.setStroke(selectedStroke);
g.translate(-box.x, -box.y);
g.draw(copy);
hotspot = new Point(-box.x, -box.y);
}
// Now begin dragging the line, specifying the listener
// object to receive notifications about the progress of
// the operation. Note: the startDrag( ) method is defined by
// the event object, which is unusual.
e.startDrag(null, // Use default drag-and-drop cursors
dragImage, // Use the image, if supported
hotspot, // Ditto for the image hotspot
t, // Drag this object
dragSourceListener); // Send notifications here
}
};
/**
* If this component is the source of a drag,
then this DragSourceListener
* will receive notifications about the progress of the drag.
The only
* one we use here is dragDropEnd( )
which is called after a drop occurs.
* We could use the other methods
to change cursors or perform other
* "drag over effects"
*/
public DragSourceListener dragSourceListener =
new DragSourceListener( ) {
// Invoked when dragging stops
public void dragDropEnd(DragSourceDropEvent e) {
if (!e.getDropSuccess( )) return; // Ignore failed drops
// If the drop was a move, then delete the selected line
if (e.getDropAction( ) == DnDConstants.ACTION_MOVE) {
lines.remove(selectedLine);
selectedLine = null;
repaint( );
}
}
// The following methods are unused here. We could implement them
// to change custom cursors or perform other "drag over effects".
public void dragEnter(DragSourceDragEvent e) { }
public void dragExit(DragSourceEvent e) { }
public void dragOver(DragSourceDragEvent e) { }
public void dropActionChanged(DragSourceDragEvent e) { }
};
/**
* This DropTargetListener is notified when something is dragged over
* this component.
*/
public DropTargetListener dropTargetListener =
new DropTargetListener( ) {
// This method is called when something is dragged over us.
// If we understand what is being dragged, then tell the system
// we can accept it, and change our border to provide extra
// "drag under" visual feedback to the user to indicate our
// receptivity to a drop.
public void dragEnter(DropTargetDragEvent e) {
if (e.isDataFlavorSupported(TransferablePolyLine.FLAVOR)) {
e.acceptDrag(e.getDropAction( ));
setBorder(canDropBorder);
}
}
// Revert to our normal border if the drag moves off us.
public void dragExit(DropTargetEvent e) { setBorder(normalBorder); }
// This method is called when something is dropped on us.
public void drop(DropTargetDropEvent e) {
// If a PolyLine is dropped, accept either a COPY or a MOVE
if (e.isDataFlavorSupported(TransferablePolyLine.FLAVOR))
e.acceptDrop(e.getDropAction( ));
else { // Otherwise, reject the drop and return
e.rejectDrop( );
return;
}
// Get the dropped object and extract a PolyLine from it
Transferable t = e.getTransferable( );
PolyLine line;
try {
line =
(PolyLine)t.getTransferData(TransferablePolyLine.FLAVOR);
}
catch(Exception ex) { // UnsupportedFlavor or IOException
getToolkit( ).beep( ); // Something went wrong, so beep
e.dropComplete(false); // Tell the system we failed
return;
}
// Figure out where the drop occurred, and translate so the
// point that was formerly (0,0) is now at that point.
Point p = e.getLocation( );
line.translate((float)p.getX( ), (float)p.getY( ));
// Add the line to our list, and repaint
lines.add(line);
repaint( );
// Tell the system that we successfully completed the transfer.
// This means it is safe for the initiating component to delete
// its copy of the line
e.dropComplete(true);
}
// We could provide additional drag under effects with this method.
public void dragOver(DropTargetDragEvent e) { }
// If we used custom cursors, we would update them here.
public void dropActionChanged(DropTargetDragEvent e) { }
};
}
