1 /*
   2  * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package javax.swing;
  26 
  27 import java.awt.*;
  28 import java.awt.event.*;
  29 import java.awt.datatransfer.*;
  30 import java.awt.dnd.*;
  31 import java.beans.*;
  32 import java.lang.reflect.*;
  33 import java.io.*;
  34 import java.util.TooManyListenersException;
  35 import javax.swing.plaf.UIResource;
  36 import javax.swing.event.*;
  37 import javax.swing.text.JTextComponent;
  38 
  39 import sun.reflect.misc.MethodUtil;
  40 import sun.swing.SwingUtilities2;
  41 import sun.awt.AppContext;
  42 import sun.swing.*;
  43 import sun.awt.SunToolkit;
  44 
  45 import java.security.AccessController;
  46 import java.security.PrivilegedAction;
  47 
  48 import java.security.AccessControlContext;
  49 import java.security.ProtectionDomain;
  50 import sun.misc.SharedSecrets;
  51 import sun.misc.JavaSecurityAccess;
  52 
  53 import sun.awt.AWTAccessor;
  54 
  55 /**
  56  * This class is used to handle the transfer of a <code>Transferable</code>
  57  * to and from Swing components.  The <code>Transferable</code> is used to
  58  * represent data that is exchanged via a cut, copy, or paste
  59  * to/from a clipboard.  It is also used in drag-and-drop operations
  60  * to represent a drag from a component, and a drop to a component.
  61  * Swing provides functionality that automatically supports cut, copy,
  62  * and paste keyboard bindings that use the functionality provided by
  63  * an implementation of this class.  Swing also provides functionality
  64  * that automatically supports drag and drop that uses the functionality
  65  * provided by an implementation of this class.  The Swing developer can
  66  * concentrate on specifying the semantics of a transfer primarily by setting
  67  * the <code>transferHandler</code> property on a Swing component.
  68  * <p>
  69  * This class is implemented to provide a default behavior of transferring
  70  * a component property simply by specifying the name of the property in
  71  * the constructor.  For example, to transfer the foreground color from
  72  * one component to another either via the clipboard or a drag and drop operation
  73  * a <code>TransferHandler</code> can be constructed with the string "foreground".  The
  74  * built in support will use the color returned by <code>getForeground</code> as the source
  75  * of the transfer, and <code>setForeground</code> for the target of a transfer.
  76  * <p>
  77  * Please see
  78  * <a href="http://java.sun.com/docs/books/tutorial/uiswing/misc/dnd.html">
  79  * How to Use Drag and Drop and Data Transfer</a>,
  80  * a section in <em>The Java Tutorial</em>, for more information.
  81  *
  82  *
  83  * @author Timothy Prinzing
  84  * @author Shannon Hickey
  85  * @since 1.4
  86  */
  87 @SuppressWarnings("serial")
  88 public class TransferHandler implements Serializable {
  89 
  90     /**
  91      * An <code>int</code> representing no transfer action.
  92      */
  93     public static final int NONE = DnDConstants.ACTION_NONE;
  94 
  95     /**
  96      * An <code>int</code> representing a &quot;copy&quot; transfer action.
  97      * This value is used when data is copied to a clipboard
  98      * or copied elsewhere in a drag and drop operation.
  99      */
 100     public static final int COPY = DnDConstants.ACTION_COPY;
 101 
 102     /**
 103      * An <code>int</code> representing a &quot;move&quot; transfer action.
 104      * This value is used when data is moved to a clipboard (i.e. a cut)
 105      * or moved elsewhere in a drag and drop operation.
 106      */
 107     public static final int MOVE = DnDConstants.ACTION_MOVE;
 108 
 109     /**
 110      * An <code>int</code> representing a source action capability of either
 111      * &quot;copy&quot; or &quot;move&quot;.
 112      */
 113     public static final int COPY_OR_MOVE = DnDConstants.ACTION_COPY_OR_MOVE;
 114 
 115     /**
 116      * An <code>int</code> representing a &quot;link&quot; transfer action.
 117      * This value is used to specify that data should be linked in a drag
 118      * and drop operation.
 119      *
 120      * @see java.awt.dnd.DnDConstants#ACTION_LINK
 121      * @since 1.6
 122      */
 123     public static final int LINK = DnDConstants.ACTION_LINK;
 124 
 125     /**
 126      * An interface to tag things with a {@code getTransferHandler} method.
 127      */
 128     interface HasGetTransferHandler {
 129 
 130         /** Returns the {@code TransferHandler}.
 131          *
 132          * @return The {@code TransferHandler} or {@code null}
 133          */
 134         public TransferHandler getTransferHandler();
 135     }
 136 
 137     /**
 138      * Represents a location where dropped data should be inserted.
 139      * This is a base class that only encapsulates a point.
 140      * Components supporting drop may provide subclasses of this
 141      * containing more information.
 142      * <p>
 143      * Developers typically shouldn't create instances of, or extend, this
 144      * class. Instead, these are something provided by the DnD
 145      * implementation by <code>TransferSupport</code> instances and by
 146      * components with a <code>getDropLocation()</code> method.
 147      *
 148      * @see javax.swing.TransferHandler.TransferSupport#getDropLocation
 149      * @since 1.6
 150      */
 151     public static class DropLocation {
 152         private final Point dropPoint;
 153 
 154         /**
 155          * Constructs a drop location for the given point.
 156          *
 157          * @param dropPoint the drop point, representing the mouse's
 158          *        current location within the component.
 159          * @throws IllegalArgumentException if the point
 160          *         is <code>null</code>
 161          */
 162         protected DropLocation(Point dropPoint) {
 163             if (dropPoint == null) {
 164                 throw new IllegalArgumentException("Point cannot be null");
 165             }
 166 
 167             this.dropPoint = new Point(dropPoint);
 168         }
 169 
 170         /**
 171          * Returns the drop point, representing the mouse's
 172          * current location within the component.
 173          *
 174          * @return the drop point.
 175          */
 176         public final Point getDropPoint() {
 177             return new Point(dropPoint);
 178         }
 179 
 180         /**
 181          * Returns a string representation of this drop location.
 182          * This method is intended to be used for debugging purposes,
 183          * and the content and format of the returned string may vary
 184          * between implementations.
 185          *
 186          * @return a string representation of this drop location
 187          */
 188         public String toString() {
 189             return getClass().getName() + "[dropPoint=" + dropPoint + "]";
 190         }
 191     };
 192 
 193     /**
 194      * This class encapsulates all relevant details of a clipboard
 195      * or drag and drop transfer, and also allows for customizing
 196      * aspects of the drag and drop experience.
 197      * <p>
 198      * The main purpose of this class is to provide the information
 199      * needed by a developer to determine the suitability of a
 200      * transfer or to import the data contained within. But it also
 201      * doubles as a controller for customizing properties during drag
 202      * and drop, such as whether or not to show the drop location,
 203      * and which drop action to use.
 204      * <p>
 205      * Developers typically need not create instances of this
 206      * class. Instead, they are something provided by the DnD
 207      * implementation to certain methods in <code>TransferHandler</code>.
 208      *
 209      * @see #canImport(TransferHandler.TransferSupport)
 210      * @see #importData(TransferHandler.TransferSupport)
 211      * @since 1.6
 212      */
 213     public final static class TransferSupport {
 214         private boolean isDrop;
 215         private Component component;
 216 
 217         private boolean showDropLocationIsSet;
 218         private boolean showDropLocation;
 219 
 220         private int dropAction = -1;
 221 
 222         /**
 223          * The source is a {@code DropTargetDragEvent} or
 224          * {@code DropTargetDropEvent} for drops,
 225          * and a {@code Transferable} otherwise
 226          */
 227         private Object source;
 228 
 229         private DropLocation dropLocation;
 230 
 231         /**
 232          * Create a <code>TransferSupport</code> with <code>isDrop()</code>
 233          * <code>true</code> for the given component, event, and index.
 234          *
 235          * @param component the target component
 236          * @param event a <code>DropTargetEvent</code>
 237          */
 238         private TransferSupport(Component component,
 239                              DropTargetEvent event) {
 240 
 241             isDrop = true;
 242             setDNDVariables(component, event);
 243         }
 244 
 245         /**
 246          * Create a <code>TransferSupport</code> with <code>isDrop()</code>
 247          * <code>false</code> for the given component and
 248          * <code>Transferable</code>.
 249          *
 250          * @param component the target component
 251          * @param transferable the transferable
 252          * @throws NullPointerException if either parameter
 253          *         is <code>null</code>
 254          */
 255         public TransferSupport(Component component, Transferable transferable) {
 256             if (component == null) {
 257                 throw new NullPointerException("component is null");
 258             }
 259 
 260             if (transferable == null) {
 261                 throw new NullPointerException("transferable is null");
 262             }
 263 
 264             isDrop = false;
 265             this.component = component;
 266             this.source = transferable;
 267         }
 268 
 269         /**
 270          * Allows for a single instance to be reused during DnD.
 271          *
 272          * @param component the target component
 273          * @param event a <code>DropTargetEvent</code>
 274          */
 275         private void setDNDVariables(Component component,
 276                                      DropTargetEvent event) {
 277 
 278             assert isDrop;
 279 
 280             this.component = component;
 281             this.source = event;
 282             dropLocation = null;
 283             dropAction = -1;
 284             showDropLocationIsSet = false;
 285 
 286             if (source == null) {
 287                 return;
 288             }
 289 
 290             assert source instanceof DropTargetDragEvent ||
 291                    source instanceof DropTargetDropEvent;
 292 
 293             Point p = source instanceof DropTargetDragEvent
 294                           ? ((DropTargetDragEvent)source).getLocation()
 295                           : ((DropTargetDropEvent)source).getLocation();
 296 
 297             if (SunToolkit.isInstanceOf(component, "javax.swing.text.JTextComponent")) {
 298                 dropLocation = SwingAccessor.getJTextComponentAccessor().
 299                                    dropLocationForPoint((JTextComponent)component, p);
 300             } else if (component instanceof JComponent) {
 301                 dropLocation = ((JComponent)component).dropLocationForPoint(p);
 302             }
 303 
 304             /*
 305              * The drop location may be null at this point if the component
 306              * doesn't return custom drop locations. In this case, a point-only
 307              * drop location will be created lazily when requested.
 308              */
 309         }
 310 
 311         /**
 312          * Returns whether or not this <code>TransferSupport</code>
 313          * represents a drop operation.
 314          *
 315          * @return <code>true</code> if this is a drop operation,
 316          *         <code>false</code> otherwise.
 317          */
 318         public boolean isDrop() {
 319             return isDrop;
 320         }
 321 
 322         /**
 323          * Returns the target component of this transfer.
 324          *
 325          * @return the target component
 326          */
 327         public Component getComponent() {
 328             return component;
 329         }
 330 
 331         /**
 332          * Checks that this is a drop and throws an
 333          * {@code IllegalStateException} if it isn't.
 334          *
 335          * @throws IllegalStateException if {@code isDrop} is false.
 336          */
 337         private void assureIsDrop() {
 338             if (!isDrop) {
 339                 throw new IllegalStateException("Not a drop");
 340             }
 341         }
 342 
 343         /**
 344          * Returns the current (non-{@code null}) drop location for the component,
 345          * when this {@code TransferSupport} represents a drop.
 346          * <p>
 347          * Note: For components with built-in drop support, this location
 348          * will be a subclass of {@code DropLocation} of the same type
 349          * returned by that component's {@code getDropLocation} method.
 350          * <p>
 351          * This method is only for use with drag and drop transfers.
 352          * Calling it when {@code isDrop()} is {@code false} results
 353          * in an {@code IllegalStateException}.
 354          *
 355          * @return the drop location
 356          * @throws IllegalStateException if this is not a drop
 357          * @see #isDrop()
 358          */
 359         public DropLocation getDropLocation() {
 360             assureIsDrop();
 361 
 362             if (dropLocation == null) {
 363                 /*
 364                  * component didn't give us a custom drop location,
 365                  * so lazily create a point-only location
 366                  */
 367                 Point p = source instanceof DropTargetDragEvent
 368                               ? ((DropTargetDragEvent)source).getLocation()
 369                               : ((DropTargetDropEvent)source).getLocation();
 370 
 371                 dropLocation = new DropLocation(p);
 372             }
 373 
 374             return dropLocation;
 375         }
 376 
 377         /**
 378          * Sets whether or not the drop location should be visually indicated
 379          * for the transfer - which must represent a drop. This is applicable to
 380          * those components that automatically
 381          * show the drop location when appropriate during a drag and drop
 382          * operation). By default, the drop location is shown only when the
 383          * {@code TransferHandler} has said it can accept the import represented
 384          * by this {@code TransferSupport}. With this method you can force the
 385          * drop location to always be shown, or always not be shown.
 386          * <p>
 387          * This method is only for use with drag and drop transfers.
 388          * Calling it when {@code isDrop()} is {@code false} results
 389          * in an {@code IllegalStateException}.
 390          *
 391          * @param showDropLocation whether or not to indicate the drop location
 392          * @throws IllegalStateException if this is not a drop
 393          * @see #isDrop()
 394          */
 395         public void setShowDropLocation(boolean showDropLocation) {
 396             assureIsDrop();
 397 
 398             this.showDropLocation = showDropLocation;
 399             this.showDropLocationIsSet = true;
 400         }
 401 
 402         /**
 403          * Sets the drop action for the transfer - which must represent a drop
 404          * - to the given action,
 405          * instead of the default user drop action. The action must be
 406          * supported by the source's drop actions, and must be one
 407          * of {@code COPY}, {@code MOVE} or {@code LINK}.
 408          * <p>
 409          * This method is only for use with drag and drop transfers.
 410          * Calling it when {@code isDrop()} is {@code false} results
 411          * in an {@code IllegalStateException}.
 412          *
 413          * @param dropAction the drop action
 414          * @throws IllegalStateException if this is not a drop
 415          * @throws IllegalArgumentException if an invalid action is specified
 416          * @see #getDropAction
 417          * @see #getUserDropAction
 418          * @see #getSourceDropActions
 419          * @see #isDrop()
 420          */
 421         public void setDropAction(int dropAction) {
 422             assureIsDrop();
 423 
 424             int action = dropAction & getSourceDropActions();
 425 
 426             if (!(action == COPY || action == MOVE || action == LINK)) {
 427                 throw new IllegalArgumentException("unsupported drop action: " + dropAction);
 428             }
 429 
 430             this.dropAction = dropAction;
 431         }
 432 
 433         /**
 434          * Returns the action chosen for the drop, when this
 435          * {@code TransferSupport} represents a drop.
 436          * <p>
 437          * Unless explicitly chosen by way of {@code setDropAction},
 438          * this returns the user drop action provided by
 439          * {@code getUserDropAction}.
 440          * <p>
 441          * You may wish to query this in {@code TransferHandler}'s
 442          * {@code importData} method to customize processing based
 443          * on the action.
 444          * <p>
 445          * This method is only for use with drag and drop transfers.
 446          * Calling it when {@code isDrop()} is {@code false} results
 447          * in an {@code IllegalStateException}.
 448          *
 449          * @return the action chosen for the drop
 450          * @throws IllegalStateException if this is not a drop
 451          * @see #setDropAction
 452          * @see #getUserDropAction
 453          * @see #isDrop()
 454          */
 455         public int getDropAction() {
 456             return dropAction == -1 ? getUserDropAction() : dropAction;
 457         }
 458 
 459         /**
 460          * Returns the user drop action for the drop, when this
 461          * {@code TransferSupport} represents a drop.
 462          * <p>
 463          * The user drop action is chosen for a drop as described in the
 464          * documentation for {@link java.awt.dnd.DropTargetDragEvent} and
 465          * {@link java.awt.dnd.DropTargetDropEvent}. A different action
 466          * may be chosen as the drop action by way of the {@code setDropAction}
 467          * method.
 468          * <p>
 469          * You may wish to query this in {@code TransferHandler}'s
 470          * {@code canImport} method when determining the suitability of a
 471          * drop or when deciding on a drop action to explicitly choose.
 472          * <p>
 473          * This method is only for use with drag and drop transfers.
 474          * Calling it when {@code isDrop()} is {@code false} results
 475          * in an {@code IllegalStateException}.
 476          *
 477          * @return the user drop action
 478          * @throws IllegalStateException if this is not a drop
 479          * @see #setDropAction
 480          * @see #getDropAction
 481          * @see #isDrop()
 482          */
 483         public int getUserDropAction() {
 484             assureIsDrop();
 485 
 486             return (source instanceof DropTargetDragEvent)
 487                 ? ((DropTargetDragEvent)source).getDropAction()
 488                 : ((DropTargetDropEvent)source).getDropAction();
 489         }
 490 
 491         /**
 492          * Returns the drag source's supported drop actions, when this
 493          * {@code TransferSupport} represents a drop.
 494          * <p>
 495          * The source actions represent the set of actions supported by the
 496          * source of this transfer, and are represented as some bitwise-OR
 497          * combination of {@code COPY}, {@code MOVE} and {@code LINK}.
 498          * You may wish to query this in {@code TransferHandler}'s
 499          * {@code canImport} method when determining the suitability of a drop
 500          * or when deciding on a drop action to explicitly choose. To determine
 501          * if a particular action is supported by the source, bitwise-AND
 502          * the action with the source drop actions, and then compare the result
 503          * against the original action. For example:
 504          * <pre>
 505          * boolean copySupported = (COPY & getSourceDropActions()) == COPY;
 506          * </pre>
 507          * <p>
 508          * This method is only for use with drag and drop transfers.
 509          * Calling it when {@code isDrop()} is {@code false} results
 510          * in an {@code IllegalStateException}.
 511          *
 512          * @return the drag source's supported drop actions
 513          * @throws IllegalStateException if this is not a drop
 514          * @see #isDrop()
 515          */
 516         public int getSourceDropActions() {
 517             assureIsDrop();
 518 
 519             return (source instanceof DropTargetDragEvent)
 520                 ? ((DropTargetDragEvent)source).getSourceActions()
 521                 : ((DropTargetDropEvent)source).getSourceActions();
 522         }
 523 
 524         /**
 525          * Returns the data flavors for this transfer.
 526          *
 527          * @return the data flavors for this transfer
 528          */
 529         public DataFlavor[] getDataFlavors() {
 530             if (isDrop) {
 531                 if (source instanceof DropTargetDragEvent) {
 532                     return ((DropTargetDragEvent)source).getCurrentDataFlavors();
 533                 } else {
 534                     return ((DropTargetDropEvent)source).getCurrentDataFlavors();
 535                 }
 536             }
 537 
 538             return ((Transferable)source).getTransferDataFlavors();
 539         }
 540 
 541         /**
 542          * Returns whether or not the given data flavor is supported.
 543          *
 544          * @param df the <code>DataFlavor</code> to test
 545          * @return whether or not the given flavor is supported.
 546          */
 547         public boolean isDataFlavorSupported(DataFlavor df) {
 548             if (isDrop) {
 549                 if (source instanceof DropTargetDragEvent) {
 550                     return ((DropTargetDragEvent)source).isDataFlavorSupported(df);
 551                 } else {
 552                     return ((DropTargetDropEvent)source).isDataFlavorSupported(df);
 553                 }
 554             }
 555 
 556             return ((Transferable)source).isDataFlavorSupported(df);
 557         }
 558 
 559         /**
 560          * Returns the <code>Transferable</code> associated with this transfer.
 561          * <p>
 562          * Note: Unless it is necessary to fetch the <code>Transferable</code>
 563          * directly, use one of the other methods on this class to inquire about
 564          * the transfer. This may perform better than fetching the
 565          * <code>Transferable</code> and asking it directly.
 566          *
 567          * @return the <code>Transferable</code> associated with this transfer
 568          */
 569         public Transferable getTransferable() {
 570             if (isDrop) {
 571                 if (source instanceof DropTargetDragEvent) {
 572                     return ((DropTargetDragEvent)source).getTransferable();
 573                 } else {
 574                     return ((DropTargetDropEvent)source).getTransferable();
 575                 }
 576             }
 577 
 578             return (Transferable)source;
 579         }
 580     }
 581 
 582 
 583     /**
 584      * Returns an {@code Action} that performs cut operations to the
 585      * clipboard. When performed, this action operates on the {@code JComponent}
 586      * source of the {@code ActionEvent} by invoking {@code exportToClipboard},
 587      * with a {@code MOVE} action, on the component's {@code TransferHandler}.
 588      *
 589      * @return an {@code Action} for performing cuts to the clipboard
 590      */
 591     public static Action getCutAction() {
 592         return cutAction;
 593     }
 594 
 595     /**
 596      * Returns an {@code Action} that performs copy operations to the
 597      * clipboard. When performed, this action operates on the {@code JComponent}
 598      * source of the {@code ActionEvent} by invoking {@code exportToClipboard},
 599      * with a {@code COPY} action, on the component's {@code TransferHandler}.
 600      *
 601      * @return an {@code Action} for performing copies to the clipboard
 602      */
 603     public static Action getCopyAction() {
 604         return copyAction;
 605     }
 606 
 607     /**
 608      * Returns an {@code Action} that performs paste operations from the
 609      * clipboard. When performed, this action operates on the {@code JComponent}
 610      * source of the {@code ActionEvent} by invoking {@code importData},
 611      * with the clipboard contents, on the component's {@code TransferHandler}.
 612      *
 613      * @return an {@code Action} for performing pastes from the clipboard
 614      */
 615     public static Action getPasteAction() {
 616         return pasteAction;
 617     }
 618 
 619 
 620     /**
 621      * Constructs a transfer handler that can transfer a Java Bean property
 622      * from one component to another via the clipboard or a drag and drop
 623      * operation.
 624      *
 625      * @param property  the name of the property to transfer; this can
 626      *  be <code>null</code> if there is no property associated with the transfer
 627      *  handler (a subclass that performs some other kind of transfer, for example)
 628      */
 629     public TransferHandler(String property) {
 630         propertyName = property;
 631     }
 632 
 633     /**
 634      * Convenience constructor for subclasses.
 635      */
 636     protected TransferHandler() {
 637         this(null);
 638     }
 639 
 640 
 641     /**
 642      * image for the {@code startDrag} method
 643      *
 644      * @see java.awt.dnd.DragGestureEvent#startDrag(Cursor dragCursor, Image dragImage, Point imageOffset, Transferable transferable, DragSourceListener dsl)
 645      */
 646     private  Image dragImage;
 647 
 648     /**
 649      * anchor offset for the {@code startDrag} method
 650      *
 651      * @see java.awt.dnd.DragGestureEvent#startDrag(Cursor dragCursor, Image dragImage, Point imageOffset, Transferable transferable, DragSourceListener dsl)
 652      */
 653     private  Point dragImageOffset;
 654 
 655     /**
 656      * Sets the drag image parameter. The image has to be prepared
 657      * for rendering by the moment of the call. The image is stored
 658      * by reference because of some performance reasons.
 659      *
 660      * @param img an image to drag
 661      */
 662     public void setDragImage(Image img) {
 663         dragImage = img;
 664     }
 665 
 666     /**
 667      * Returns the drag image. If there is no image to drag,
 668      * the returned value is {@code null}.
 669      *
 670      * @return the reference to the drag image
 671      */
 672     public Image getDragImage() {
 673         return dragImage;
 674     }
 675 
 676     /**
 677      * Sets an anchor offset for the image to drag.
 678      * It can not be {@code null}.
 679      *
 680      * @param p a {@code Point} object that corresponds
 681      * to coordinates of an anchor offset of the image
 682      * relative to the upper left corner of the image
 683      */
 684     public void setDragImageOffset(Point p) {
 685         dragImageOffset = new Point(p);
 686     }
 687 
 688     /**
 689      * Returns an anchor offset for the image to drag.
 690      *
 691      * @return a {@code Point} object that corresponds
 692      * to coordinates of an anchor offset of the image
 693      * relative to the upper left corner of the image.
 694      * The point {@code (0,0)} returns by default.
 695      */
 696     public Point getDragImageOffset() {
 697         if (dragImageOffset == null) {
 698             return new Point(0,0);
 699         }
 700         return new Point(dragImageOffset);
 701     }
 702 
 703     /**
 704      * Causes the Swing drag support to be initiated.  This is called by
 705      * the various UI implementations in the <code>javax.swing.plaf.basic</code>
 706      * package if the dragEnabled property is set on the component.
 707      * This can be called by custom UI
 708      * implementations to use the Swing drag support.  This method can also be called
 709      * by a Swing extension written as a subclass of <code>JComponent</code>
 710      * to take advantage of the Swing drag support.
 711      * <p>
 712      * The transfer <em>will not necessarily</em> have been completed at the
 713      * return of this call (i.e. the call does not block waiting for the drop).
 714      * The transfer will take place through the Swing implementation of the
 715      * <code>java.awt.dnd</code> mechanism, requiring no further effort
 716      * from the developer. The <code>exportDone</code> method will be called
 717      * when the transfer has completed.
 718      *
 719      * @param comp  the component holding the data to be transferred;
 720      *              provided to enable sharing of <code>TransferHandler</code>s
 721      * @param e     the event that triggered the transfer
 722      * @param action the transfer action initially requested;
 723      *               either {@code COPY}, {@code MOVE} or {@code LINK};
 724      *               the DnD system may change the action used during the
 725      *               course of the drag operation
 726      */
 727     public void exportAsDrag(JComponent comp, InputEvent e, int action) {
 728         int srcActions = getSourceActions(comp);
 729 
 730         // only mouse events supported for drag operations
 731         if (!(e instanceof MouseEvent)
 732                 // only support known actions
 733                 || !(action == COPY || action == MOVE || action == LINK)
 734                 // only support valid source actions
 735                 || (srcActions & action) == 0) {
 736 
 737             action = NONE;
 738         }
 739 
 740         if (action != NONE && !GraphicsEnvironment.isHeadless()) {
 741             if (recognizer == null) {
 742                 recognizer = new SwingDragGestureRecognizer(new DragHandler());
 743             }
 744             recognizer.gestured(comp, (MouseEvent)e, srcActions, action);
 745         } else {
 746             exportDone(comp, null, NONE);
 747         }
 748     }
 749 
 750     /**
 751      * Causes a transfer from the given component to the
 752      * given clipboard.  This method is called by the default cut and
 753      * copy actions registered in a component's action map.
 754      * <p>
 755      * The transfer will take place using the <code>java.awt.datatransfer</code>
 756      * mechanism, requiring no further effort from the developer. Any data
 757      * transfer <em>will</em> be complete and the <code>exportDone</code>
 758      * method will be called with the action that occurred, before this method
 759      * returns. Should the clipboard be unavailable when attempting to place
 760      * data on it, the <code>IllegalStateException</code> thrown by
 761      * {@link Clipboard#setContents(Transferable, ClipboardOwner)} will
 762      * be propogated through this method. However,
 763      * <code>exportDone</code> will first be called with an action
 764      * of <code>NONE</code> for consistency.
 765      *
 766      * @param comp  the component holding the data to be transferred;
 767      *              provided to enable sharing of <code>TransferHandler</code>s
 768      * @param clip  the clipboard to transfer the data into
 769      * @param action the transfer action requested; this should
 770      *  be a value of either <code>COPY</code> or <code>MOVE</code>;
 771      *  the operation performed is the intersection  of the transfer
 772      *  capabilities given by getSourceActions and the requested action;
 773      *  the intersection may result in an action of <code>NONE</code>
 774      *  if the requested action isn't supported
 775      * @throws IllegalStateException if the clipboard is currently unavailable
 776      * @see Clipboard#setContents(Transferable, ClipboardOwner)
 777      */
 778     public void exportToClipboard(JComponent comp, Clipboard clip, int action)
 779                                                   throws IllegalStateException {
 780 
 781         if ((action == COPY || action == MOVE)
 782                 && (getSourceActions(comp) & action) != 0) {
 783 
 784             Transferable t = createTransferable(comp);
 785             if (t != null) {
 786                 try {
 787                     clip.setContents(t, null);
 788                     exportDone(comp, t, action);
 789                     return;
 790                 } catch (IllegalStateException ise) {
 791                     exportDone(comp, t, NONE);
 792                     throw ise;
 793                 }
 794             }
 795         }
 796 
 797         exportDone(comp, null, NONE);
 798     }
 799 
 800     /**
 801      * Causes a transfer to occur from a clipboard or a drag and
 802      * drop operation. The <code>Transferable</code> to be
 803      * imported and the component to transfer to are contained
 804      * within the <code>TransferSupport</code>.
 805      * <p>
 806      * While the drag and drop implementation calls {@code canImport}
 807      * to determine the suitability of a transfer before calling this
 808      * method, the implementation of paste does not. As such, it cannot
 809      * be assumed that the transfer is acceptable upon a call to
 810      * this method for paste. It is recommended that {@code canImport} be
 811      * explicitly called to cover this case.
 812      * <p>
 813      * Note: The <code>TransferSupport</code> object passed to this method
 814      * is only valid for the duration of the method call. It is undefined
 815      * what values it may contain after this method returns.
 816      *
 817      * @param support the object containing the details of
 818      *        the transfer, not <code>null</code>.
 819      * @return true if the data was inserted into the component,
 820      *         false otherwise
 821      * @throws NullPointerException if <code>support</code> is {@code null}
 822      * @see #canImport(TransferHandler.TransferSupport)
 823      * @since 1.6
 824      */
 825     public boolean importData(TransferSupport support) {
 826         return support.getComponent() instanceof JComponent
 827             ? importData((JComponent)support.getComponent(), support.getTransferable())
 828             : false;
 829     }
 830 
 831     /**
 832      * Causes a transfer to a component from a clipboard or a
 833      * DND drop operation.  The <code>Transferable</code> represents
 834      * the data to be imported into the component.
 835      * <p>
 836      * Note: Swing now calls the newer version of <code>importData</code>
 837      * that takes a <code>TransferSupport</code>, which in turn calls this
 838      * method (if the component in the {@code TransferSupport} is a
 839      * {@code JComponent}). Developers are encouraged to call and override the
 840      * newer version as it provides more information (and is the only
 841      * version that supports use with a {@code TransferHandler} set directly
 842      * on a {@code JFrame} or other non-{@code JComponent}).
 843      *
 844      * @param comp  the component to receive the transfer;
 845      *              provided to enable sharing of <code>TransferHandler</code>s
 846      * @param t     the data to import
 847      * @return  true if the data was inserted into the component, false otherwise
 848      * @see #importData(TransferHandler.TransferSupport)
 849      */
 850     public boolean importData(JComponent comp, Transferable t) {
 851         PropertyDescriptor prop = getPropertyDescriptor(comp);
 852         if (prop != null) {
 853             Method writer = prop.getWriteMethod();
 854             if (writer == null) {
 855                 // read-only property. ignore
 856                 return false;
 857             }
 858             Class<?>[] params = writer.getParameterTypes();
 859             if (params.length != 1) {
 860                 // zero or more than one argument, ignore
 861                 return false;
 862             }
 863             DataFlavor flavor = getPropertyDataFlavor(params[0], t.getTransferDataFlavors());
 864             if (flavor != null) {
 865                 try {
 866                     Object value = t.getTransferData(flavor);
 867                     Object[] args = { value };
 868                     MethodUtil.invoke(writer, comp, args);
 869                     return true;
 870                 } catch (Exception ex) {
 871                     System.err.println("Invocation failed");
 872                     // invocation code
 873                 }
 874             }
 875         }
 876         return false;
 877     }
 878 
 879     /**
 880      * This method is called repeatedly during a drag and drop operation
 881      * to allow the developer to configure properties of, and to return
 882      * the acceptability of transfers; with a return value of {@code true}
 883      * indicating that the transfer represented by the given
 884      * {@code TransferSupport} (which contains all of the details of the
 885      * transfer) is acceptable at the current time, and a value of {@code false}
 886      * rejecting the transfer.
 887      * <p>
 888      * For those components that automatically display a drop location during
 889      * drag and drop, accepting the transfer, by default, tells them to show
 890      * the drop location. This can be changed by calling
 891      * {@code setShowDropLocation} on the {@code TransferSupport}.
 892      * <p>
 893      * By default, when the transfer is accepted, the chosen drop action is that
 894      * picked by the user via their drag gesture. The developer can override
 895      * this and choose a different action, from the supported source
 896      * actions, by calling {@code setDropAction} on the {@code TransferSupport}.
 897      * <p>
 898      * On every call to {@code canImport}, the {@code TransferSupport} contains
 899      * fresh state. As such, any properties set on it must be set on every
 900      * call. Upon a drop, {@code canImport} is called one final time before
 901      * calling into {@code importData}. Any state set on the
 902      * {@code TransferSupport} during that last call will be available in
 903      * {@code importData}.
 904      * <p>
 905      * This method is not called internally in response to paste operations.
 906      * As such, it is recommended that implementations of {@code importData}
 907      * explicitly call this method for such cases and that this method
 908      * be prepared to return the suitability of paste operations as well.
 909      * <p>
 910      * Note: The <code>TransferSupport</code> object passed to this method
 911      * is only valid for the duration of the method call. It is undefined
 912      * what values it may contain after this method returns.
 913      *
 914      * @param support the object containing the details of
 915      *        the transfer, not <code>null</code>.
 916      * @return <code>true</code> if the import can happen,
 917      *         <code>false</code> otherwise
 918      * @throws NullPointerException if <code>support</code> is {@code null}
 919      * @see #importData(TransferHandler.TransferSupport)
 920      * @see javax.swing.TransferHandler.TransferSupport#setShowDropLocation
 921      * @see javax.swing.TransferHandler.TransferSupport#setDropAction
 922      * @since 1.6
 923      */
 924     public boolean canImport(TransferSupport support) {
 925         return support.getComponent() instanceof JComponent
 926             ? canImport((JComponent)support.getComponent(), support.getDataFlavors())
 927             : false;
 928     }
 929 
 930     /**
 931      * Indicates whether a component will accept an import of the given
 932      * set of data flavors prior to actually attempting to import it.
 933      * <p>
 934      * Note: Swing now calls the newer version of <code>canImport</code>
 935      * that takes a <code>TransferSupport</code>, which in turn calls this
 936      * method (only if the component in the {@code TransferSupport} is a
 937      * {@code JComponent}). Developers are encouraged to call and override the
 938      * newer version as it provides more information (and is the only
 939      * version that supports use with a {@code TransferHandler} set directly
 940      * on a {@code JFrame} or other non-{@code JComponent}).
 941      *
 942      * @param comp  the component to receive the transfer;
 943      *              provided to enable sharing of <code>TransferHandler</code>s
 944      * @param transferFlavors  the data formats available
 945      * @return  true if the data can be inserted into the component, false otherwise
 946      * @see #canImport(TransferHandler.TransferSupport)
 947      */
 948     public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {
 949         PropertyDescriptor prop = getPropertyDescriptor(comp);
 950         if (prop != null) {
 951             Method writer = prop.getWriteMethod();
 952             if (writer == null) {
 953                 // read-only property. ignore
 954                 return false;
 955             }
 956             Class<?>[] params = writer.getParameterTypes();
 957             if (params.length != 1) {
 958                 // zero or more than one argument, ignore
 959                 return false;
 960             }
 961             DataFlavor flavor = getPropertyDataFlavor(params[0], transferFlavors);
 962             if (flavor != null) {
 963                 return true;
 964             }
 965         }
 966         return false;
 967     }
 968 
 969     /**
 970      * Returns the type of transfer actions supported by the source;
 971      * any bitwise-OR combination of {@code COPY}, {@code MOVE}
 972      * and {@code LINK}.
 973      * <p>
 974      * Some models are not mutable, so a transfer operation of {@code MOVE}
 975      * should not be advertised in that case. Returning {@code NONE}
 976      * disables transfers from the component.
 977      *
 978      * @param c  the component holding the data to be transferred;
 979      *           provided to enable sharing of <code>TransferHandler</code>s
 980      * @return {@code COPY} if the transfer property can be found,
 981      *          otherwise returns <code>NONE</code>
 982      */
 983     public int getSourceActions(JComponent c) {
 984         PropertyDescriptor prop = getPropertyDescriptor(c);
 985         if (prop != null) {
 986             return COPY;
 987         }
 988         return NONE;
 989     }
 990 
 991     /**
 992      * Returns an object that establishes the look of a transfer.  This is
 993      * useful for both providing feedback while performing a drag operation and for
 994      * representing the transfer in a clipboard implementation that has a visual
 995      * appearance.  The implementation of the <code>Icon</code> interface should
 996      * not alter the graphics clip or alpha level.
 997      * The icon implementation need not be rectangular or paint all of the
 998      * bounding rectangle and logic that calls the icons paint method should
 999      * not assume the all bits are painted. <code>null</code> is a valid return value
1000      * for this method and indicates there is no visual representation provided.
1001      * In that case, the calling logic is free to represent the
1002      * transferable however it wants.
1003      * <p>
1004      * The default Swing logic will not do an alpha blended drag animation if
1005      * the return is <code>null</code>.
1006      *
1007      * @param t  the data to be transferred; this value is expected to have been
1008      *  created by the <code>createTransferable</code> method
1009      * @return  <code>null</code>, indicating
1010      *    there is no default visual representation
1011      */
1012     public Icon getVisualRepresentation(Transferable t) {
1013         return null;
1014     }
1015 
1016     /**
1017      * Creates a <code>Transferable</code> to use as the source for
1018      * a data transfer. Returns the representation of the data to
1019      * be transferred, or <code>null</code> if the component's
1020      * property is <code>null</code>
1021      *
1022      * @param c  the component holding the data to be transferred;
1023      *              provided to enable sharing of <code>TransferHandler</code>s
1024      * @return  the representation of the data to be transferred, or
1025      *  <code>null</code> if the property associated with <code>c</code>
1026      *  is <code>null</code>
1027      *
1028      */
1029     protected Transferable createTransferable(JComponent c) {
1030         PropertyDescriptor property = getPropertyDescriptor(c);
1031         if (property != null) {
1032             return new PropertyTransferable(property, c);
1033         }
1034         return null;
1035     }
1036 
1037     /**
1038      * Invoked after data has been exported.  This method should remove
1039      * the data that was transferred if the action was <code>MOVE</code>.
1040      * <p>
1041      * This method is implemented to do nothing since <code>MOVE</code>
1042      * is not a supported action of this implementation
1043      * (<code>getSourceActions</code> does not include <code>MOVE</code>).
1044      *
1045      * @param source the component that was the source of the data
1046      * @param data   The data that was transferred or possibly null
1047      *               if the action is <code>NONE</code>.
1048      * @param action the actual action that was performed
1049      */
1050     protected void exportDone(JComponent source, Transferable data, int action) {
1051     }
1052 
1053     /**
1054      * Fetches the property descriptor for the property assigned to this transfer
1055      * handler on the given component (transfer handler may be shared).  This
1056      * returns <code>null</code> if the property descriptor can't be found
1057      * or there is an error attempting to fetch the property descriptor.
1058      */
1059     private PropertyDescriptor getPropertyDescriptor(JComponent comp) {
1060         if (propertyName == null) {
1061             return null;
1062         }
1063         Class<?> k = comp.getClass();
1064         BeanInfo bi;
1065         try {
1066             bi = Introspector.getBeanInfo(k);
1067         } catch (IntrospectionException ex) {
1068             return null;
1069         }
1070         PropertyDescriptor props[] = bi.getPropertyDescriptors();
1071         for (int i=0; i < props.length; i++) {
1072             if (propertyName.equals(props[i].getName())) {
1073                 Method reader = props[i].getReadMethod();
1074 
1075                 if (reader != null) {
1076                     Class<?>[] params = reader.getParameterTypes();
1077 
1078                     if (params == null || params.length == 0) {
1079                         // found the desired descriptor
1080                         return props[i];
1081                     }
1082                 }
1083             }
1084         }
1085         return null;
1086     }
1087 
1088     /**
1089      * Fetches the data flavor from the array of possible flavors that
1090      * has data of the type represented by property type.  Null is
1091      * returned if there is no match.
1092      */
1093     private DataFlavor getPropertyDataFlavor(Class<?> k, DataFlavor[] flavors) {
1094         for(int i = 0; i < flavors.length; i++) {
1095             DataFlavor flavor = flavors[i];
1096             if ("application".equals(flavor.getPrimaryType()) &&
1097                 "x-java-jvm-local-objectref".equals(flavor.getSubType()) &&
1098                 k.isAssignableFrom(flavor.getRepresentationClass())) {
1099 
1100                 return flavor;
1101             }
1102         }
1103         return null;
1104     }
1105 
1106 
1107     private String propertyName;
1108     private static SwingDragGestureRecognizer recognizer = null;
1109 
1110     private static DropTargetListener getDropTargetListener() {
1111         synchronized(DropHandler.class) {
1112             DropHandler handler =
1113                 (DropHandler)AppContext.getAppContext().get(DropHandler.class);
1114 
1115             if (handler == null) {
1116                 handler = new DropHandler();
1117                 AppContext.getAppContext().put(DropHandler.class, handler);
1118             }
1119 
1120             return handler;
1121         }
1122     }
1123 
1124     static class PropertyTransferable implements Transferable {
1125 
1126         PropertyTransferable(PropertyDescriptor p, JComponent c) {
1127             property = p;
1128             component = c;
1129         }
1130 
1131         // --- Transferable methods ----------------------------------------------
1132 
1133         /**
1134          * Returns an array of <code>DataFlavor</code> objects indicating the flavors the data
1135          * can be provided in.  The array should be ordered according to preference
1136          * for providing the data (from most richly descriptive to least descriptive).
1137          * @return an array of data flavors in which this data can be transferred
1138          */
1139         public DataFlavor[] getTransferDataFlavors() {
1140             DataFlavor[] flavors = new DataFlavor[1];
1141             Class<?> propertyType = property.getPropertyType();
1142             String mimeType = DataFlavor.javaJVMLocalObjectMimeType + ";class=" + propertyType.getName();
1143             try {
1144                 flavors[0] = new DataFlavor(mimeType);
1145             } catch (ClassNotFoundException cnfe) {
1146                 flavors = new DataFlavor[0];
1147             }
1148             return flavors;
1149         }
1150 
1151         /**
1152          * Returns whether the specified data flavor is supported for
1153          * this object.
1154          * @param flavor the requested flavor for the data
1155          * @return true if this <code>DataFlavor</code> is supported,
1156          *   otherwise false
1157          */
1158         public boolean isDataFlavorSupported(DataFlavor flavor) {
1159             Class<?> propertyType = property.getPropertyType();
1160             if ("application".equals(flavor.getPrimaryType()) &&
1161                 "x-java-jvm-local-objectref".equals(flavor.getSubType()) &&
1162                 flavor.getRepresentationClass().isAssignableFrom(propertyType)) {
1163 
1164                 return true;
1165             }
1166             return false;
1167         }
1168 
1169         /**
1170          * Returns an object which represents the data to be transferred.  The class
1171          * of the object returned is defined by the representation class of the flavor.
1172          *
1173          * @param flavor the requested flavor for the data
1174          * @see DataFlavor#getRepresentationClass
1175          * @exception IOException                if the data is no longer available
1176          *              in the requested flavor.
1177          * @exception UnsupportedFlavorException if the requested data flavor is
1178          *              not supported.
1179          */
1180         public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
1181             if (! isDataFlavorSupported(flavor)) {
1182                 throw new UnsupportedFlavorException(flavor);
1183             }
1184             Method reader = property.getReadMethod();
1185             Object value = null;
1186             try {
1187                 value = MethodUtil.invoke(reader, component, (Object[])null);
1188             } catch (Exception ex) {
1189                 throw new IOException("Property read failed: " + property.getName());
1190             }
1191             return value;
1192         }
1193 
1194         JComponent component;
1195         PropertyDescriptor property;
1196     }
1197 
1198     /**
1199      * This is the default drop target for drag and drop operations if
1200      * one isn't provided by the developer.  <code>DropTarget</code>
1201      * only supports one <code>DropTargetListener</code> and doesn't
1202      * function properly if it isn't set.
1203      * This class sets the one listener as the linkage of drop handling
1204      * to the <code>TransferHandler</code>, and adds support for
1205      * additional listeners which some of the <code>ComponentUI</code>
1206      * implementations install to manipulate a drop insertion location.
1207      */
1208     static class SwingDropTarget extends DropTarget implements UIResource {
1209 
1210         SwingDropTarget(Component c) {
1211             super(c, COPY_OR_MOVE | LINK, null);
1212             try {
1213                 // addDropTargetListener is overridden
1214                 // we specifically need to add to the superclass
1215                 super.addDropTargetListener(getDropTargetListener());
1216             } catch (TooManyListenersException tmle) {}
1217         }
1218 
1219         public void addDropTargetListener(DropTargetListener dtl) throws TooManyListenersException {
1220             // Since the super class only supports one DropTargetListener,
1221             // and we add one from the constructor, we always add to the
1222             // extended list.
1223             if (listenerList == null) {
1224                 listenerList = new EventListenerList();
1225             }
1226             listenerList.add(DropTargetListener.class, dtl);
1227         }
1228 
1229         public void removeDropTargetListener(DropTargetListener dtl) {
1230             if (listenerList != null) {
1231                 listenerList.remove(DropTargetListener.class, dtl);
1232             }
1233         }
1234 
1235         // --- DropTargetListener methods (multicast) --------------------------
1236 
1237         public void dragEnter(DropTargetDragEvent e) {
1238             super.dragEnter(e);
1239             if (listenerList != null) {
1240                 Object[] listeners = listenerList.getListenerList();
1241                 for (int i = listeners.length-2; i>=0; i-=2) {
1242                     if (listeners[i]==DropTargetListener.class) {
1243                         ((DropTargetListener)listeners[i+1]).dragEnter(e);
1244                     }
1245                 }
1246             }
1247         }
1248 
1249         public void dragOver(DropTargetDragEvent e) {
1250             super.dragOver(e);
1251             if (listenerList != null) {
1252                 Object[] listeners = listenerList.getListenerList();
1253                 for (int i = listeners.length-2; i>=0; i-=2) {
1254                     if (listeners[i]==DropTargetListener.class) {
1255                         ((DropTargetListener)listeners[i+1]).dragOver(e);
1256                     }
1257                 }
1258             }
1259         }
1260 
1261         public void dragExit(DropTargetEvent e) {
1262             super.dragExit(e);
1263             if (listenerList != null) {
1264                 Object[] listeners = listenerList.getListenerList();
1265                 for (int i = listeners.length-2; i>=0; i-=2) {
1266                     if (listeners[i]==DropTargetListener.class) {
1267                         ((DropTargetListener)listeners[i+1]).dragExit(e);
1268                     }
1269                 }
1270             }
1271             if (!isActive()) {
1272                 // If the Drop target is inactive the dragExit will not be dispatched to the dtListener,
1273                 // so make sure that we clean up the dtListener anyway.
1274                 DropTargetListener dtListener = getDropTargetListener();
1275                     if (dtListener != null && dtListener instanceof DropHandler) {
1276                         ((DropHandler)dtListener).cleanup(false);
1277                     }
1278             }
1279         }
1280 
1281         public void drop(DropTargetDropEvent e) {
1282             super.drop(e);
1283             if (listenerList != null) {
1284                 Object[] listeners = listenerList.getListenerList();
1285                 for (int i = listeners.length-2; i>=0; i-=2) {
1286                     if (listeners[i]==DropTargetListener.class) {
1287                         ((DropTargetListener)listeners[i+1]).drop(e);
1288                     }
1289                 }
1290             }
1291         }
1292 
1293         public void dropActionChanged(DropTargetDragEvent e) {
1294             super.dropActionChanged(e);
1295             if (listenerList != null) {
1296                 Object[] listeners = listenerList.getListenerList();
1297                 for (int i = listeners.length-2; i>=0; i-=2) {
1298                     if (listeners[i]==DropTargetListener.class) {
1299                         ((DropTargetListener)listeners[i+1]).dropActionChanged(e);
1300                     }
1301                 }
1302             }
1303         }
1304 
1305         private EventListenerList listenerList;
1306     }
1307 
1308     private static class DropHandler implements DropTargetListener,
1309                                                 Serializable,
1310                                                 ActionListener {
1311 
1312         private Timer timer;
1313         private Point lastPosition;
1314         private Rectangle outer = new Rectangle();
1315         private Rectangle inner = new Rectangle();
1316         private int hysteresis = 10;
1317 
1318         private Component component;
1319         private Object state;
1320         private TransferSupport support =
1321             new TransferSupport(null, (DropTargetEvent)null);
1322 
1323         private static final int AUTOSCROLL_INSET = 10;
1324 
1325         /**
1326          * Update the geometry of the autoscroll region.  The geometry is
1327          * maintained as a pair of rectangles.  The region can cause
1328          * a scroll if the pointer sits inside it for the duration of the
1329          * timer.  The region that causes the timer countdown is the area
1330          * between the two rectangles.
1331          * <p>
1332          * This is implemented to use the visible area of the component
1333          * as the outer rectangle, and the insets are fixed at 10. Should
1334          * the component be smaller than a total of 20 in any direction,
1335          * autoscroll will not occur in that direction.
1336          */
1337         private void updateAutoscrollRegion(JComponent c) {
1338             // compute the outer
1339             Rectangle visible = c.getVisibleRect();
1340             outer.setBounds(visible.x, visible.y, visible.width, visible.height);
1341 
1342             // compute the insets
1343             Insets i = new Insets(0, 0, 0, 0);
1344             if (c instanceof Scrollable) {
1345                 int minSize = 2 * AUTOSCROLL_INSET;
1346 
1347                 if (visible.width >= minSize) {
1348                     i.left = i.right = AUTOSCROLL_INSET;
1349                 }
1350 
1351                 if (visible.height >= minSize) {
1352                     i.top = i.bottom = AUTOSCROLL_INSET;
1353                 }
1354             }
1355 
1356             // set the inner from the insets
1357             inner.setBounds(visible.x + i.left,
1358                           visible.y + i.top,
1359                           visible.width - (i.left + i.right),
1360                           visible.height - (i.top  + i.bottom));
1361         }
1362 
1363         /**
1364          * Perform an autoscroll operation.  This is implemented to scroll by the
1365          * unit increment of the Scrollable using scrollRectToVisible.  If the
1366          * cursor is in a corner of the autoscroll region, more than one axis will
1367          * scroll.
1368          */
1369         private void autoscroll(JComponent c, Point pos) {
1370             if (c instanceof Scrollable) {
1371                 Scrollable s = (Scrollable) c;
1372                 if (pos.y < inner.y) {
1373                     // scroll upward
1374                     int dy = s.getScrollableUnitIncrement(outer, SwingConstants.VERTICAL, -1);
1375                     Rectangle r = new Rectangle(inner.x, outer.y - dy, inner.width, dy);
1376                     c.scrollRectToVisible(r);
1377                 } else if (pos.y > (inner.y + inner.height)) {
1378                     // scroll downard
1379                     int dy = s.getScrollableUnitIncrement(outer, SwingConstants.VERTICAL, 1);
1380                     Rectangle r = new Rectangle(inner.x, outer.y + outer.height, inner.width, dy);
1381                     c.scrollRectToVisible(r);
1382                 }
1383 
1384                 if (pos.x < inner.x) {
1385                     // scroll left
1386                     int dx = s.getScrollableUnitIncrement(outer, SwingConstants.HORIZONTAL, -1);
1387                     Rectangle r = new Rectangle(outer.x - dx, inner.y, dx, inner.height);
1388                     c.scrollRectToVisible(r);
1389                 } else if (pos.x > (inner.x + inner.width)) {
1390                     // scroll right
1391                     int dx = s.getScrollableUnitIncrement(outer, SwingConstants.HORIZONTAL, 1);
1392                     Rectangle r = new Rectangle(outer.x + outer.width, inner.y, dx, inner.height);
1393                     c.scrollRectToVisible(r);
1394                 }
1395             }
1396         }
1397 
1398         /**
1399          * Initializes the internal properties if they haven't been already
1400          * inited. This is done lazily to avoid loading of desktop properties.
1401          */
1402         private void initPropertiesIfNecessary() {
1403             if (timer == null) {
1404                 Toolkit t = Toolkit.getDefaultToolkit();
1405                 Integer prop;
1406 
1407                 prop = (Integer)
1408                     t.getDesktopProperty("DnD.Autoscroll.interval");
1409 
1410                 timer = new Timer(prop == null ? 100 : prop.intValue(), this);
1411 
1412                 prop = (Integer)
1413                     t.getDesktopProperty("DnD.Autoscroll.initialDelay");
1414 
1415                 timer.setInitialDelay(prop == null ? 100 : prop.intValue());
1416 
1417                 prop = (Integer)
1418                     t.getDesktopProperty("DnD.Autoscroll.cursorHysteresis");
1419 
1420                 if (prop != null) {
1421                     hysteresis = prop.intValue();
1422                 }
1423             }
1424         }
1425 
1426         /**
1427          * The timer fired, perform autoscroll if the pointer is within the
1428          * autoscroll region.
1429          * <P>
1430          * @param e the <code>ActionEvent</code>
1431          */
1432         public void actionPerformed(ActionEvent e) {
1433             updateAutoscrollRegion((JComponent)component);
1434             if (outer.contains(lastPosition) && !inner.contains(lastPosition)) {
1435                 autoscroll((JComponent)component, lastPosition);
1436             }
1437         }
1438 
1439         // --- DropTargetListener methods -----------------------------------
1440 
1441         private void setComponentDropLocation(TransferSupport support,
1442                                               boolean forDrop) {
1443 
1444             DropLocation dropLocation = (support == null)
1445                                         ? null
1446                                         : support.getDropLocation();
1447 
1448             if (SunToolkit.isInstanceOf(component, "javax.swing.text.JTextComponent")) {
1449                 state = SwingAccessor.getJTextComponentAccessor().
1450                             setDropLocation((JTextComponent)component, dropLocation, state, forDrop);
1451             } else if (component instanceof JComponent) {
1452                 state = ((JComponent)component).setDropLocation(dropLocation, state, forDrop);
1453             }
1454         }
1455 
1456         private void handleDrag(DropTargetDragEvent e) {
1457             TransferHandler importer =
1458                 ((HasGetTransferHandler)component).getTransferHandler();
1459 
1460             if (importer == null) {
1461                 e.rejectDrag();
1462                 setComponentDropLocation(null, false);
1463                 return;
1464             }
1465 
1466             support.setDNDVariables(component, e);
1467             boolean canImport = importer.canImport(support);
1468 
1469             if (canImport) {
1470                 e.acceptDrag(support.getDropAction());
1471             } else {
1472                 e.rejectDrag();
1473             }
1474 
1475             boolean showLocation = support.showDropLocationIsSet ?
1476                                    support.showDropLocation :
1477                                    canImport;
1478 
1479             setComponentDropLocation(showLocation ? support : null, false);
1480         }
1481 
1482         public void dragEnter(DropTargetDragEvent e) {
1483             state = null;
1484             component = e.getDropTargetContext().getComponent();
1485 
1486             handleDrag(e);
1487 
1488             if (component instanceof JComponent) {
1489                 lastPosition = e.getLocation();
1490                 updateAutoscrollRegion((JComponent)component);
1491                 initPropertiesIfNecessary();
1492             }
1493         }
1494 
1495         public void dragOver(DropTargetDragEvent e) {
1496             handleDrag(e);
1497 
1498             if (!(component instanceof JComponent)) {
1499                 return;
1500             }
1501 
1502             Point p = e.getLocation();
1503 
1504             if (Math.abs(p.x - lastPosition.x) > hysteresis
1505                     || Math.abs(p.y - lastPosition.y) > hysteresis) {
1506                 // no autoscroll
1507                 if (timer.isRunning()) timer.stop();
1508             } else {
1509                 if (!timer.isRunning()) timer.start();
1510             }
1511 
1512             lastPosition = p;
1513         }
1514 
1515         public void dragExit(DropTargetEvent e) {
1516             cleanup(false);
1517         }
1518 
1519         public void drop(DropTargetDropEvent e) {
1520             TransferHandler importer =
1521                 ((HasGetTransferHandler)component).getTransferHandler();
1522 
1523             if (importer == null) {
1524                 e.rejectDrop();
1525                 cleanup(false);
1526                 return;
1527             }
1528 
1529             support.setDNDVariables(component, e);
1530             boolean canImport = importer.canImport(support);
1531 
1532             if (canImport) {
1533                 e.acceptDrop(support.getDropAction());
1534 
1535                 boolean showLocation = support.showDropLocationIsSet ?
1536                                        support.showDropLocation :
1537                                        canImport;
1538 
1539                 setComponentDropLocation(showLocation ? support : null, false);
1540 
1541                 boolean success;
1542 
1543                 try {
1544                     success = importer.importData(support);
1545                 } catch (RuntimeException re) {
1546                     success = false;
1547                 }
1548 
1549                 e.dropComplete(success);
1550                 cleanup(success);
1551             } else {
1552                 e.rejectDrop();
1553                 cleanup(false);
1554             }
1555         }
1556 
1557         public void dropActionChanged(DropTargetDragEvent e) {
1558             /*
1559              * Work-around for Linux bug where dropActionChanged
1560              * is called before dragEnter.
1561              */
1562             if (component == null) {
1563                 return;
1564             }
1565 
1566             handleDrag(e);
1567         }
1568 
1569         void cleanup(boolean forDrop) {
1570             setComponentDropLocation(null, forDrop);
1571             if (component instanceof JComponent) {
1572                 ((JComponent)component).dndDone();
1573             }
1574 
1575             if (timer != null) {
1576                 timer.stop();
1577             }
1578 
1579             state = null;
1580             component = null;
1581             lastPosition = null;
1582         }
1583     }
1584 
1585     /**
1586      * This is the default drag handler for drag and drop operations that
1587      * use the <code>TransferHandler</code>.
1588      */
1589     private static class DragHandler implements DragGestureListener, DragSourceListener {
1590 
1591         private boolean scrolls;
1592 
1593         // --- DragGestureListener methods -----------------------------------
1594 
1595         /**
1596          * a Drag gesture has been recognized
1597          */
1598         public void dragGestureRecognized(DragGestureEvent dge) {
1599             JComponent c = (JComponent) dge.getComponent();
1600             TransferHandler th = c.getTransferHandler();
1601             Transferable t = th.createTransferable(c);
1602             if (t != null) {
1603                 scrolls = c.getAutoscrolls();
1604                 c.setAutoscrolls(false);
1605                 try {
1606                     Image im = th.getDragImage();
1607                     if (im == null) {
1608                         dge.startDrag(null, t, this);
1609                     } else {
1610                         dge.startDrag(null, im, th.getDragImageOffset(), t, this);
1611                     }
1612                     return;
1613                 } catch (RuntimeException re) {
1614                     c.setAutoscrolls(scrolls);
1615                 }
1616             }
1617 
1618             th.exportDone(c, t, NONE);
1619         }
1620 
1621         // --- DragSourceListener methods -----------------------------------
1622 
1623         /**
1624          * as the hotspot enters a platform dependent drop site
1625          */
1626         public void dragEnter(DragSourceDragEvent dsde) {
1627         }
1628 
1629         /**
1630          * as the hotspot moves over a platform dependent drop site
1631          */
1632         public void dragOver(DragSourceDragEvent dsde) {
1633         }
1634 
1635         /**
1636          * as the hotspot exits a platform dependent drop site
1637          */
1638         public void dragExit(DragSourceEvent dsde) {
1639         }
1640 
1641         /**
1642          * as the operation completes
1643          */
1644         public void dragDropEnd(DragSourceDropEvent dsde) {
1645             DragSourceContext dsc = dsde.getDragSourceContext();
1646             JComponent c = (JComponent)dsc.getComponent();
1647             if (dsde.getDropSuccess()) {
1648                 c.getTransferHandler().exportDone(c, dsc.getTransferable(), dsde.getDropAction());
1649             } else {
1650                 c.getTransferHandler().exportDone(c, dsc.getTransferable(), NONE);
1651             }
1652             c.setAutoscrolls(scrolls);
1653         }
1654 
1655         public void dropActionChanged(DragSourceDragEvent dsde) {
1656         }
1657     }
1658 
1659     private static class SwingDragGestureRecognizer extends DragGestureRecognizer {
1660 
1661         SwingDragGestureRecognizer(DragGestureListener dgl) {
1662             super(DragSource.getDefaultDragSource(), null, NONE, dgl);
1663         }
1664 
1665         void gestured(JComponent c, MouseEvent e, int srcActions, int action) {
1666             setComponent(c);
1667             setSourceActions(srcActions);
1668             appendEvent(e);
1669             fireDragGestureRecognized(action, e.getPoint());
1670         }
1671 
1672         /**
1673          * register this DragGestureRecognizer's Listeners with the Component
1674          */
1675         protected void registerListeners() {
1676         }
1677 
1678         /**
1679          * unregister this DragGestureRecognizer's Listeners with the Component
1680          *
1681          * subclasses must override this method
1682          */
1683         protected void unregisterListeners() {
1684         }
1685 
1686     }
1687 
1688     static final Action cutAction = new TransferAction("cut");
1689     static final Action copyAction = new TransferAction("copy");
1690     static final Action pasteAction = new TransferAction("paste");
1691 
1692     static class TransferAction extends UIAction implements UIResource {
1693 
1694         TransferAction(String name) {
1695             super(name);
1696         }
1697 
1698         public boolean isEnabled(Object sender) {
1699             if (sender instanceof JComponent
1700                 && ((JComponent)sender).getTransferHandler() == null) {
1701                     return false;
1702             }
1703 
1704             return true;
1705         }
1706 
1707         private static final JavaSecurityAccess javaSecurityAccess =
1708             SharedSecrets.getJavaSecurityAccess();
1709 
1710         public void actionPerformed(final ActionEvent e) {
1711             final Object src = e.getSource();
1712 
1713             final PrivilegedAction<Void> action = new PrivilegedAction<Void>() {
1714                 public Void run() {
1715                     actionPerformedImpl(e);
1716                     return null;
1717                 }
1718             };
1719 
1720             final AccessControlContext stack = AccessController.getContext();
1721             final AccessControlContext srcAcc = AWTAccessor.getComponentAccessor().getAccessControlContext((Component)src);
1722             final AccessControlContext eventAcc = AWTAccessor.getAWTEventAccessor().getAccessControlContext(e);
1723 
1724                 if (srcAcc == null) {
1725                     javaSecurityAccess.doIntersectionPrivilege(action, stack, eventAcc);
1726                 } else {
1727                     javaSecurityAccess.doIntersectionPrivilege(
1728                         new PrivilegedAction<Void>() {
1729                             public Void run() {
1730                                 javaSecurityAccess.doIntersectionPrivilege(action, eventAcc);
1731                                 return null;
1732                              }
1733                     }, stack, srcAcc);
1734                 }
1735         }
1736 
1737         private void actionPerformedImpl(ActionEvent e) {
1738             Object src = e.getSource();
1739             if (src instanceof JComponent) {
1740                 JComponent c = (JComponent) src;
1741                 TransferHandler th = c.getTransferHandler();
1742                 Clipboard clipboard = getClipboard(c);
1743                 String name = (String) getValue(Action.NAME);
1744 
1745                 Transferable trans = null;
1746 
1747                 // any of these calls may throw IllegalStateException
1748                 try {
1749                     if ((clipboard != null) && (th != null) && (name != null)) {
1750                         if ("cut".equals(name)) {
1751                             th.exportToClipboard(c, clipboard, MOVE);
1752                         } else if ("copy".equals(name)) {
1753                             th.exportToClipboard(c, clipboard, COPY);
1754                         } else if ("paste".equals(name)) {
1755                             trans = clipboard.getContents(null);
1756                         }
1757                     }
1758                 } catch (IllegalStateException ise) {
1759                     // clipboard was unavailable
1760                     UIManager.getLookAndFeel().provideErrorFeedback(c);
1761                     return;
1762                 }
1763 
1764                 // this is a paste action, import data into the component
1765                 if (trans != null) {
1766                     th.importData(new TransferSupport(c, trans));
1767                 }
1768             }
1769         }
1770 
1771         /**
1772          * Returns the clipboard to use for cut/copy/paste.
1773          */
1774         private Clipboard getClipboard(JComponent c) {
1775             if (SwingUtilities2.canAccessSystemClipboard()) {
1776                 return c.getToolkit().getSystemClipboard();
1777             }
1778             Clipboard clipboard = (Clipboard)sun.awt.AppContext.getAppContext().
1779                 get(SandboxClipboardKey);
1780             if (clipboard == null) {
1781                 clipboard = new Clipboard("Sandboxed Component Clipboard");
1782                 sun.awt.AppContext.getAppContext().put(SandboxClipboardKey,
1783                                                        clipboard);
1784             }
1785             return clipboard;
1786         }
1787 
1788         /**
1789          * Key used in app context to lookup Clipboard to use if access to
1790          * System clipboard is denied.
1791          */
1792         private static Object SandboxClipboardKey = new Object();
1793 
1794     }
1795 
1796 }
--- EOF ---