Java 类java.awt.dnd.InvalidDnDOperationException 实例源码

/**
 * reject Drop
 */

public synchronized void rejectDrop() {
    if (dropStatus != STATUS_WAIT) {
        throw new InvalidDnDOperationException("invalid rejectDrop()");
    }
    dropStatus = STATUS_REJECT;
    /*
     * Fix for 4285634.
     * The target rejected the drop means that it doesn't perform any
     * drop action. This change is to make Solaris behavior consistent
     * with Win32.
     */
    currentDA = DnDConstants.ACTION_NONE;
    dropComplete(false);
}

void dispatchEvent(SunDropTargetEvent e) {
    int id = e.getID();

    switch (id) {
    case SunDropTargetEvent.MOUSE_ENTERED:
        dispatchEnterEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DRAGGED:
        dispatchMotionEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_EXITED:
        dispatchExitEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DROPPED:
        dispatchDropEvent(e);
        break;
    default:
        throw new InvalidDnDOperationException();
    }
}

/**
 * Initializes a drag operation with the specified supported drop actions,
 * contents and data formats.
 *
 * @param actions a bitwise mask of <code>DnDConstants</code> that represent
 *                the supported drop actions.
 * @param contents the contents for the drag operation.
 * @param formats an array of Atoms that represent the supported data formats.
 * @param formats an array of Atoms that represent the supported data formats.
 * @throws InvalidDnDOperationException if a drag operation is already
 * initialized.
 * @throws IllegalArgumentException if some argument has invalid value.
 * @throws XException if some X call failed.
 */
public final void initializeDrag(int actions, Transferable contents,
                                 Map formatMap, long[] formats)
  throws InvalidDnDOperationException,
         IllegalArgumentException, XException {
    XToolkit.awtLock();
    try {
        try {
            if (initialized) {
                throw new InvalidDnDOperationException("Already initialized");
            }

            initializeDragImpl(actions, contents, formatMap, formats);

            initialized = true;
        } finally {
            if (!initialized) {
                cleanup();
            }
        }
    } finally {
        XToolkit.awtUnlock();
    }
}

/**
 * reject Drop
 */

public synchronized void rejectDrop() {
    if (dropStatus != STATUS_WAIT) {
        throw new InvalidDnDOperationException("invalid rejectDrop()");
    }
    dropStatus = STATUS_REJECT;
    /*
     * Fix for 4285634.
     * The target rejected the drop means that it doesn't perform any
     * drop action. This change is to make Solaris behavior consistent
     * with Win32.
     */
    currentDA = DnDConstants.ACTION_NONE;
    dropComplete(false);
}

void dispatchEvent(SunDropTargetEvent e) {
    int id = e.getID();

    switch (id) {
    case SunDropTargetEvent.MOUSE_ENTERED:
        dispatchEnterEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DRAGGED:
        dispatchMotionEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_EXITED:
        dispatchExitEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DROPPED:
        dispatchDropEvent(e);
        break;
    default:
        throw new InvalidDnDOperationException();
    }
}

/**
 * Initializes a drag operation with the specified supported drop actions,
 * contents and data formats.
 *
 * @param actions a bitwise mask of <code>DnDConstants</code> that represent
 *                the supported drop actions.
 * @param contents the contents for the drag operation.
 * @param formats an array of Atoms that represent the supported data formats.
 * @param formats an array of Atoms that represent the supported data formats.
 * @throws InvalidDnDOperationException if a drag operation is already
 * initialized.
 * @throws IllegalArgumentException if some argument has invalid value.
 * @throws XException if some X call failed.
 */
public final void initializeDrag(int actions, Transferable contents,
                                 Map formatMap, long[] formats)
  throws InvalidDnDOperationException,
         IllegalArgumentException, XException {
    XToolkit.awtLock();
    try {
        try {
            if (initialized) {
                throw new InvalidDnDOperationException("Already initialized");
            }

            initializeDragImpl(actions, contents, formatMap, formats);

            initialized = true;
        } finally {
            if (!initialized) {
                cleanup();
            }
        }
    } finally {
        XToolkit.awtUnlock();
    }
}

/**
 * reject Drop
 */

public synchronized void rejectDrop() {
    if (dropStatus != STATUS_WAIT) {
        throw new InvalidDnDOperationException("invalid rejectDrop()");
    }
    dropStatus = STATUS_REJECT;
    /*
     * Fix for 4285634.
     * The target rejected the drop means that it doesn't perform any
     * drop action. This change is to make Solaris behavior consistent
     * with Win32.
     */
    currentDA = DnDConstants.ACTION_NONE;
    dropComplete(false);
}

void dispatchEvent(SunDropTargetEvent e) {
    int id = e.getID();

    switch (id) {
    case SunDropTargetEvent.MOUSE_ENTERED:
        dispatchEnterEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DRAGGED:
        dispatchMotionEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_EXITED:
        dispatchExitEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DROPPED:
        dispatchDropEvent(e);
        break;
    default:
        throw new InvalidDnDOperationException();
    }
}

/**
 * Initializes a drag operation with the specified supported drop actions,
 * contents and data formats.
 *
 * @param actions a bitwise mask of {@code DnDConstants} that represent
 *                the supported drop actions.
 * @param contents the contents for the drag operation.
 * @param formats an array of Atoms that represent the supported data formats.
 * @param formats an array of Atoms that represent the supported data formats.
 * @throws InvalidDnDOperationException if a drag operation is already
 * initialized.
 * @throws IllegalArgumentException if some argument has invalid value.
 * @throws XException if some X call failed.
 */
public final void initializeDrag(int actions, Transferable contents,
                                 Map<Long, DataFlavor> formatMap, long[] formats)
  throws InvalidDnDOperationException,
         IllegalArgumentException, XException {
    XToolkit.awtLock();
    try {
        try {
            if (initialized) {
                throw new InvalidDnDOperationException("Already initialized");
            }

            initializeDragImpl(actions, contents, formatMap, formats);

            initialized = true;
        } finally {
            if (!initialized) {
                cleanup();
            }
        }
    } finally {
        XToolkit.awtUnlock();
    }
}

/**
 * reject Drop
 */

public synchronized void rejectDrop() {
    if (dropStatus != STATUS_WAIT) {
        throw new InvalidDnDOperationException("invalid rejectDrop()");
    }
    dropStatus = STATUS_REJECT;
    /*
     * Fix for 4285634.
     * The target rejected the drop means that it doesn't perform any
     * drop action. This change is to make Solaris behavior consistent
     * with Win32.
     */
    currentDA = DnDConstants.ACTION_NONE;
    dropComplete(false);
}

void dispatchEvent(SunDropTargetEvent e) {
    int id = e.getID();

    switch (id) {
    case SunDropTargetEvent.MOUSE_ENTERED:
        dispatchEnterEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DRAGGED:
        dispatchMotionEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_EXITED:
        dispatchExitEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DROPPED:
        dispatchDropEvent(e);
        break;
    default:
        throw new InvalidDnDOperationException();
    }
}

/**
 * Initializes a drag operation with the specified supported drop actions,
 * contents and data formats.
 *
 * @param actions a bitwise mask of {@code DnDConstants} that represent
 *                the supported drop actions.
 * @param contents the contents for the drag operation.
 * @param formats an array of Atoms that represent the supported data formats.
 * @param formats an array of Atoms that represent the supported data formats.
 * @throws InvalidDnDOperationException if a drag operation is already
 * initialized.
 * @throws IllegalArgumentException if some argument has invalid value.
 * @throws XException if some X call failed.
 */
public final void initializeDrag(int actions, Transferable contents,
                                 Map<Long, DataFlavor> formatMap, long[] formats)
  throws InvalidDnDOperationException,
         IllegalArgumentException, XException {
    XToolkit.awtLock();
    try {
        try {
            if (initialized) {
                throw new InvalidDnDOperationException("Already initialized");
            }

            initializeDragImpl(actions, contents, formatMap, formats);

            initialized = true;
        } finally {
            if (!initialized) {
                cleanup();
            }
        }
    } finally {
        XToolkit.awtUnlock();
    }
}

/**
 * reject Drop
 */

public synchronized void rejectDrop() {
    if (dropStatus != STATUS_WAIT) {
        throw new InvalidDnDOperationException("invalid rejectDrop()");
    }
    dropStatus = STATUS_REJECT;
    /*
     * Fix for 4285634.
     * The target rejected the drop means that it doesn't perform any
     * drop action. This change is to make Solaris behavior consistent
     * with Win32.
     */
    currentDA = DnDConstants.ACTION_NONE;
    dropComplete(false);
}

void dispatchEvent(SunDropTargetEvent e) {
    int id = e.getID();

    switch (id) {
    case SunDropTargetEvent.MOUSE_ENTERED:
        dispatchEnterEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DRAGGED:
        dispatchMotionEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_EXITED:
        dispatchExitEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DROPPED:
        dispatchDropEvent(e);
        break;
    default:
        throw new InvalidDnDOperationException();
    }
}

/**
 * reject Drop
 */

public synchronized void rejectDrop() {
    if (dropStatus != STATUS_WAIT) {
        throw new InvalidDnDOperationException("invalid rejectDrop()");
    }
    dropStatus = STATUS_REJECT;
    /*
     * Fix for 4285634.
     * The target rejected the drop means that it doesn't perform any
     * drop action. This change is to make Solaris behavior consistent
     * with Win32.
     */
    currentDA = DnDConstants.ACTION_NONE;
    dropComplete(false);
}

void dispatchEvent(SunDropTargetEvent e) {
    int id = e.getID();

    switch (id) {
    case SunDropTargetEvent.MOUSE_ENTERED:
        dispatchEnterEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DRAGGED:
        dispatchMotionEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_EXITED:
        dispatchExitEvent(e);
        break;
    case SunDropTargetEvent.MOUSE_DROPPED:
        dispatchDropEvent(e);
        break;
    default:
        throw new InvalidDnDOperationException();
    }
}

/**
 * Initializes a drag operation with the specified supported drop actions,
 * contents and data formats.
 *
 * @param actions a bitwise mask of <code>DnDConstants</code> that represent
 *                the supported drop actions.
 * @param contents the contents for the drag operation.
 * @param formats an array of Atoms that represent the supported data formats.
 * @param formats an array of Atoms that represent the supported data formats.
 * @throws InvalidDnDOperationException if a drag operation is already
 * initialized.
 * @throws IllegalArgumentException if some argument has invalid value.
 * @throws XException if some X call failed.
 */
public final void initializeDrag(int actions, Transferable contents,
                                 Map formatMap, long[] formats)
  throws InvalidDnDOperationException,
         IllegalArgumentException, XException {
    XToolkit.awtLock();
    try {
        try {
            if (initialized) {
                throw new InvalidDnDOperationException("Already initialized");
            }

            initializeDragImpl(actions, contents, formatMap, formats);

            initialized = true;
        } finally {
            if (!initialized) {
                cleanup();
            }
        }
    } finally {
        XToolkit.awtUnlock();
    }
}

public void dragGestureRecognized( DragGestureEvent dge ) {
    Transferable t = null;

    if( dge.getComponent() instanceof CategoryButton ) {
        //trying to drag a palette category
        CategoryButton button = (CategoryButton)dge.getComponent();
        draggingCategory = button.getCategory();
        t = draggingCategory.getTransferable();

    } else if( dge.getComponent() instanceof CategoryList ) {
        //trying to drag a palette item
        CategoryList list = (CategoryList)dge.getComponent();
        int selIndex = list.locationToIndex( dge.getDragOrigin() );
        draggingItem = list.getItemAt( selIndex );
        if( null == draggingItem ) {
            return;
        }
        t = draggingItem.drag();
        dragSourceCategoryList = list;
    }
    if( null != t ) {
        dge.getDragSource().addDragSourceListener( getDragSourceListener() );
        try {
            dge.startDrag( null, t );
        } catch( InvalidDnDOperationException idndE ) {
            //attempt to fix #110670
            try {
                dge.startDrag( null, t );
            } catch( InvalidDnDOperationException e ) {
                ERR.log( Level.INFO, idndE.getMessage(), e );
            }
        }
    }
}

/** Initiating the drag */
public void dragGestureRecognized(DragGestureEvent dge) {
    // check allowed actions
    if ((dge.getDragAction() & DnDConstants.ACTION_MOVE) == 0) {
        return;
    }

    // prepare transferable and start the drag
    int index = comp.locationToIndex(dge.getDragOrigin());

    // no index, then no dragging...
    if (index < 0) {
        return;
    }

    //      System.out.println("Starting drag..."); // NOI18N
    // create our flavor for transferring the index
    myFlavor = new DataFlavor(
            String.class, NbBundle.getBundle(IndexedCustomizer.class).getString("IndexedFlavor")
        );

    try {
        dge.startDrag(DragSource.DefaultMoveDrop, new IndexTransferable(myFlavor, index), this);

        // remember the gesture
        this.dge = dge;
    } catch (InvalidDnDOperationException exc) {
        Logger.getLogger(IndexedCustomizer.class.getName()).log(Level.WARNING, null, exc);

        // PENDING notify user - cannot start the drag
    }
}

public void dragGestureRecognized(DragGestureEvent dge) {

      Point mousePosition = dge.getDragOrigin();
      Point piecePosition = new Point(myStack.pos);

      // Check drag starts inside piece
      Rectangle r = myStack.stackConfigurer.getPieceBoundingBox();
      r.translate(piecePosition.x, piecePosition.y);
      if (!r.contains(mousePosition)) {
        return;
      }

      originalPieceOffsetX = piecePosition.x - mousePosition.x;
      originalPieceOffsetY = piecePosition.y - mousePosition.y;

      drawWin = null;

      makeDragCursor();
      setDragCursor();

      SwingUtilities.convertPointToScreen(mousePosition, drawWin);
      moveDragCursor(mousePosition.x, mousePosition.y);

      // begin dragging
      try {
        dge.startDrag(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR),
                      new StringSelection(""), this); // DEBUG
        dge.getDragSource().addDragSourceMotionListener(this);
      }
      catch (InvalidDnDOperationException e) {
        ErrorDialog.bug(e);
      }
    }

public void dragGestureRecognized(DragGestureEvent dge) {

        final Point mousePosition = dge.getDragOrigin();
        dragStart = new Point(mousePosition);
        final Region r = grid.getRegion(mousePosition);
        if (r == null) {
          return;
        }

        Point piecePosition = new Point(r.getOrigin());

        originalPieceOffsetX = piecePosition.x - mousePosition.x;
        originalPieceOffsetY = piecePosition.y - mousePosition.y;

        drawWin = null;

        makeDragCursor();
        setDragCursor();

        SwingUtilities.convertPointToScreen(drawOffset, drawWin);
        SwingUtilities.convertPointToScreen(mousePosition, drawWin);
        moveDragCursor(mousePosition.x, mousePosition.y);

        // begin dragging
        try {
          dge.startDrag(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR),
                        new StringSelection(""), this); //$NON-NLS-1$
          dge.getDragSource().addDragSourceMotionListener(this);
        }
        catch (InvalidDnDOperationException e) {
          ErrorDialog.bug(e);
        }
      }

/** Fires after user begins moving the mouse several pixels over a map. */
public void dragGestureRecognized(DragGestureEvent dge) {
  try {
    beginDragging(dge);
  }
  // FIXME: Fix by replacing AWT Drag 'n Drop with Swing DnD.
  // Catch and ignore spurious DragGestures
  catch (InvalidDnDOperationException e) {
  }
}

public static void setCurrentJVMLocalSourceTransferable(Transferable t) throws InvalidDnDOperationException {
    synchronized(_globalLock) {
        if (t != null && currentJVMLocalSourceTransferable != null) {
                throw new InvalidDnDOperationException();
        } else {
            currentJVMLocalSourceTransferable = t;
        }
    }
}

/**
 * acceptDrag
 */

public synchronized void acceptDrag(int dragOperation) {
    if (currentDT == null) {
        throw new InvalidDnDOperationException("No Drag pending");
    }
    currentDA = mapOperation(dragOperation);
    if (currentDA != DnDConstants.ACTION_NONE) {
        dragRejected = false;
    }
}

/**
 * rejectDrag
 */

public synchronized void rejectDrag() {
    if (currentDT == null) {
        throw new InvalidDnDOperationException("No Drag pending");
    }
    currentDA = DnDConstants.ACTION_NONE;
    dragRejected = true;
}

/**
 * acceptDrop
 */

public synchronized void acceptDrop(int dropOperation) {
    if (dropOperation == DnDConstants.ACTION_NONE)
        throw new IllegalArgumentException("invalid acceptDrop() action");

    if (dropStatus == STATUS_WAIT || dropStatus == STATUS_ACCEPT) {
        currentDA = currentA = mapOperation(dropOperation & currentSA);

        dropStatus   = STATUS_ACCEPT;
        dropComplete = false;
    } else {
        throw new InvalidDnDOperationException("invalid acceptDrop()");
    }
}

/**
 * signal drop complete
 */

public synchronized void dropComplete(boolean success) {
    if (dropStatus == STATUS_NONE) {
        throw new InvalidDnDOperationException("No Drop pending");
    }

    if (currentDTC != null) currentDTC.removeNotify();

    currentDT  = null;
    currentDTC = null;
    currentT   = null;
    currentA   = DnDConstants.ACTION_NONE;

    synchronized(_globalLock) {
        currentJVMLocalSourceTransferable = null;
    }

    dropStatus   = STATUS_NONE;
    dropComplete = true;

    try {
        doDropDone(success, currentDA, local != null);
    } finally {
        currentDA = DnDConstants.ACTION_NONE;
        // The native context is invalid after the drop is done.
        // Clear the reference to prohibit access.
        nativeDragContext = 0;
    }
}

/**
 * initiate a DnD operation ...
 */

public void startDrag(DragSourceContext dsc, Cursor c, Image di, Point p)
  throws InvalidDnDOperationException {

    /* Fix for 4354044: don't initiate a drag if event sequence provided by
     * DragGestureRecognizer is empty */
    if (getTrigger().getTriggerEvent() == null) {
        throw new InvalidDnDOperationException("DragGestureEvent has a null trigger");
    }

    dragSourceContext = dsc;
    cursor            = c;
    sourceActions     = getDragSourceContext().getSourceActions();
    dragImage         = di;
    dragImageOffset   = p;

    Transferable transferable  = getDragSourceContext().getTransferable();
    SortedMap<Long,DataFlavor> formatMap = DataTransferer.getInstance().
        getFormatsForTransferable(transferable, DataTransferer.adaptFlavorMap
            (getTrigger().getDragSource().getFlavorMap()));
    long[] formats = DataTransferer.getInstance().
        keysToLongArray(formatMap);
    startDrag(transferable, formats, formatMap);

    /*
     * Fix for 4613903.
     * Filter out all mouse events that are currently on the event queue.
     */
    discardingMouseEvents = true;
    EventQueue.invokeLater(new Runnable() {
            public void run() {
                discardingMouseEvents = false;
            }
        });
}

/**
 * set cursor
 */

public void setCursor(Cursor c) throws InvalidDnDOperationException {
    synchronized (this) {
        if (cursor == null || !cursor.equals(c)) {
            cursor = c;
            // NOTE: native context can be null at this point.
            // setNativeCursor() should handle it properly.
            setNativeCursor(getNativeContext(), c,
                            c != null ? c.getType() : 0);
        }
    }
}

public static void setDragDropInProgress(boolean b)
  throws InvalidDnDOperationException {
    synchronized (SunDragSourceContextPeer.class) {
        if (dragDropInProgress == b) {
            throw new InvalidDnDOperationException(getExceptionMessage(b));
        }
        dragDropInProgress = b;
    }
}

/**
 * create the peer for a DragSourceContext
 */

@Override
public DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge) throws InvalidDnDOperationException {
    final LightweightFrame f = SunToolkit.getLightweightFrame(dge.getComponent());
    if (f != null) {
        return f.createDragSourceContextPeer(dge);
    }

    return WDragSourceContextPeer.createDragSourceContextPeer(dge);
}

protected void initializeDragImpl(int actions, Transferable contents,
                                  Map formatMap, long[] formats)
  throws InvalidDnDOperationException,
    IllegalArgumentException, XException {

    long window = XDragSourceProtocol.getDragSourceWindow();

    /* Write the Motif DnD initiator info on the root XWindow. */
    try {
        int index = MotifDnDConstants.getIndexForTargetList(formats);

        MotifDnDConstants.writeDragInitiatorInfoStruct(window, index);
    } catch (XException xe) {
        cleanup();
        throw xe;
    } catch (InvalidDnDOperationException idoe) {
        cleanup();
        throw idoe;
    }

    if (!MotifDnDConstants.MotifDnDSelection.setOwner(contents, formatMap,
                                                      formats,
                                                      XConstants.CurrentTime)) {
        cleanup();
        throw new InvalidDnDOperationException("Cannot acquire selection ownership");
    }
}

/**
 * set cursor
 */

public void setCursor(Cursor c) throws InvalidDnDOperationException {
    XToolkit.awtLock();
    try {
        super.setCursor(c);
    } finally {
        XToolkit.awtUnlock();
    }
}

private void throwGrabFailureException(String msg, int grabStatus)
  throws InvalidDnDOperationException {
    String msgCause = "";
    switch (grabStatus) {
    case XConstants.GrabNotViewable:  msgCause = "not viewable";    break;
    case XConstants.AlreadyGrabbed:   msgCause = "already grabbed"; break;
    case XConstants.GrabInvalidTime:  msgCause = "invalid time";    break;
    case XConstants.GrabFrozen:       msgCause = "grab frozen";     break;
    default:                           msgCause = "unknown failure"; break;
    }
    throw new InvalidDnDOperationException(msg + ": " + msgCause);
}

public DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge) throws InvalidDnDOperationException {
    final LightweightFrame f = SunToolkit.getLightweightFrame(dge.getComponent());
    if (f != null) {
        return f.createDragSourceContextPeer(dge);
    }

    return XDragSourceContextPeer.createDragSourceContextPeer(dge);
}

public static void setCurrentJVMLocalSourceTransferable(Transferable t) throws InvalidDnDOperationException {
    synchronized(_globalLock) {
        if (t != null && currentJVMLocalSourceTransferable != null) {
                throw new InvalidDnDOperationException();
        } else {
            currentJVMLocalSourceTransferable = t;
        }
    }
}

/**
 * acceptDrag
 */

public synchronized void acceptDrag(int dragOperation) {
    if (currentDT == null) {
        throw new InvalidDnDOperationException("No Drag pending");
    }
    currentDA = mapOperation(dragOperation);
    if (currentDA != DnDConstants.ACTION_NONE) {
        dragRejected = false;
    }
}

/**
 * rejectDrag
 */

public synchronized void rejectDrag() {
    if (currentDT == null) {
        throw new InvalidDnDOperationException("No Drag pending");
    }
    currentDA = DnDConstants.ACTION_NONE;
    dragRejected = true;
}

/**
 * acceptDrop
 */

public synchronized void acceptDrop(int dropOperation) {
    if (dropOperation == DnDConstants.ACTION_NONE)
        throw new IllegalArgumentException("invalid acceptDrop() action");

    if (dropStatus == STATUS_WAIT || dropStatus == STATUS_ACCEPT) {
        currentDA = currentA = mapOperation(dropOperation & currentSA);

        dropStatus   = STATUS_ACCEPT;
        dropComplete = false;
    } else {
        throw new InvalidDnDOperationException("invalid acceptDrop()");
    }
}

/**
 * signal drop complete
 */

public synchronized void dropComplete(boolean success) {
    if (dropStatus == STATUS_NONE) {
        throw new InvalidDnDOperationException("No Drop pending");
    }

    if (currentDTC != null) currentDTC.removeNotify();

    currentDT  = null;
    currentDTC = null;
    currentT   = null;
    currentA   = DnDConstants.ACTION_NONE;

    synchronized(_globalLock) {
        currentJVMLocalSourceTransferable = null;
    }

    dropStatus   = STATUS_NONE;
    dropComplete = true;

    try {
        doDropDone(success, currentDA, local != null);
    } finally {
        currentDA = DnDConstants.ACTION_NONE;
        // The native context is invalid after the drop is done.
        // Clear the reference to prohibit access.
        nativeDragContext = 0;
    }
}