java.awt.dnd.DropTargetEvent#java.awt.dnd.DropTargetDropEvent源码实例Demo

public void drop(DropTargetDropEvent e)
{
	if (dragSource != null)
	{
		e.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
		Point p = e.getLocation();
		int targetRow = rowAtPoint(p);

		Object edge = graph.insertEdge(null, null, null,
				dragSource.cell, JTableRenderer.this.cell, "sourceRow="
						+ sourceRow + ";targetRow=" + targetRow);
		graph.setSelectionCell(edge);

		// System.out.println("clearing drag source");
		dragSource = null;
		e.dropComplete(true);
	}
	else
	{
		e.rejectDrop();
	}
}
 

public void drop(DropTargetDropEvent dtde) {
    gestureStarted = false;
    if ((dtde.getDropAction() & DnDConstants.ACTION_MOVE) == DnDConstants.ACTION_MOVE) {
        dtde.acceptDrop(DnDConstants.ACTION_MOVE);
        Transferable t = dtde.getTransferable();

        try {
            DBTableInternalFrame iFrame = (DBTableInternalFrame) t
                    .getTransferData(InternalFrameTransferable.DATA_FLAVOR);
            if (iFrame != DBTableInternalFrame.this) {
                JoinLine joinLine = new JoinLine(iFrame, iFrame
                        .getSelectedRow(), DBTableInternalFrame.this,
                        columnsListBox.getSelectedIndex());
                desktop.addJoinLine(joinLine);
                desktop.repaint();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        dtde.dropComplete(true);
    }
}
 

@Override
public synchronized void drop(DropTargetDropEvent dropTargetDropEvent) {
       try {
           final Transferable transferable = dropTargetDropEvent.getTransferable();
           if (transferable.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
               dropTargetDropEvent.acceptDrop(DnDConstants.ACTION_COPY);
               dropTargetDropEvent.getDropTargetContext().dropComplete(true);
           }
           else {
               dropTargetDropEvent.rejectDrop();
           }
       }
       catch (Exception ex) {
           Log.error(ex);
           dropTargetDropEvent.rejectDrop();
       }
   }
 

@SuppressWarnings("unchecked")
@Override
public void drop(DropTargetDropEvent dtde) {
	for (DataFlavor dataFlover : dtde.getCurrentDataFlavors()) {
		if (dataFlover.isFlavorJavaFileListType()) {
			try {
				dtde.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);

				for (File file : (List<File>)dtde.getTransferable().getTransferData(DataFlavor.javaFileListFlavor)) {
					if (file.isFile() && file.canRead()) {
						browseText.setText(file.getCanonicalPath());
						break;
					}
				}

				dtde.getDropTargetContext().dropComplete(true);	
			} catch (UnsupportedFlavorException | IOException e) {
				//
			}
		}
	}
}
 

@Override
public void handle(PluginTool tool, Object obj, DropTargetDropEvent e, DataFlavor f) {
	VersionInfo info = (VersionInfo) obj;

	DomainFile file = tool.getProject().getProjectData().getFile(info.getDomainFilePath());
	GetVersionedObjectTask task =
		new GetVersionedObjectTask(this, file, info.getVersionNumber());
	tool.execute(task, 250);
	DomainObject versionedObj = task.getVersionedObject();

	if (versionedObj != null) {
		DomainFile vfile = versionedObj.getDomainFile();
		tool.acceptDomainFiles(new DomainFile[] { vfile });
		versionedObj.release(this);
	}
}
 

@Override public void drop(DropTargetDropEvent e) {
  try {
    if (e.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
      e.acceptDrop(DnDConstants.ACTION_COPY);
      Transferable transferable = e.getTransferable();
      ((List<?>) transferable.getTransferData(DataFlavor.javaFileListFlavor))
          .stream().filter(File.class::isInstance).map(File.class::cast)
          .map(File::toPath)
          .forEach(MainPanel.this::addImage);
      e.dropComplete(true);
    } else {
      e.rejectDrop();
    }
  } catch (UnsupportedFlavorException | IOException ex) {
    e.rejectDrop();
  }
}
 

private ArrayList<DefaultMutableTreeNode> onCreatePasteTreeNodesFromExternalTransfer(DropTargetDropEvent dtde, TreePath targetPath)
{
   List<File> files = DropedFileExtractor.getFiles(dtde, _app);

   ArrayList<DefaultMutableTreeNode> ret = new ArrayList<DefaultMutableTreeNode>();

   DefaultMutableTreeNode parent = findParent(targetPath);
   for (File file : files)
   {
      if (false == parentContainsFile(parent, file))
      {
         ret.add(new DefaultMutableTreeNode(file));
      }
   }

   return ret;

}
 

public void drop(DropTargetDropEvent dtde) {
    boolean res = false;
    try {
        if( isButtonDrag ) {
            if( validateDropPosition() ) {
                res = handleDrop( dtde.getTransferable() );
            }
        } else if( isToolbarDrag ) {
            res = true;
            //taken care of in dragDropEnd()
        }
    } finally {
        dtde.dropComplete(res);
    }
    resetDropGesture();
}
 

public void drop(DropTargetDropEvent event) {
    int dropAction = event.getDropAction();
    JComponent c = (JComponent) event.getDropTargetContext().getComponent();
    DataObjectTransferHandler transferHandler = (DataObjectTransferHandler) c.getTransferHandler();

    if (canImport && (transferHandler != null) && actionSupported(dropAction)) {
        event.acceptDrop(dropAction);
        try {
            Transferable transferable = event.getTransferable();
            transferHandler.setDropPoint(event.getLocation());
            transferHandler.setDropComponent(c);
            event.dropComplete(transferHandler.importData(c, transferable));
        } catch (RuntimeException e) {
            event.dropComplete(false);
        }
    } else {
        event.rejectDrop();
    }
}
 

@Override
public void drop(DropTargetDropEvent dtde) {
    if (dtde.isDataFlavorSupported(VillageTransferable.villageDataFlavor) || dtde.isDataFlavorSupported(DataFlavor.stringFlavor)) {
        dtde.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
    } else {
        dtde.rejectDrop();
        return;
    }

    Transferable t = dtde.getTransferable();
    List<Village> v;
    MapPanel.getSingleton().setCurrentCursor(MapPanel.getSingleton().getCurrentCursor());
    try {
        v = (List<Village>) t.getTransferData(VillageTransferable.villageDataFlavor);
        fireVillagesDraggedEvent(v, dtde.getLocation());
    } catch (Exception ignored) {
    }
}
 

@Override
public void drop(DropTargetDropEvent e) {
  DropTargetContext targetContext = e.getDropTargetContext();

  if ((e.getSourceActions() & DnDConstants.ACTION_COPY) != 0)
    e.acceptDrop(DnDConstants.ACTION_COPY);
  else {
    e.rejectDrop();
    return;
  }

  // We know drag is coming from tree so just get selection:
  String typeName = annotationFeaturesViewer.getSelection();
  edit.addRow(typeName);
  targetContext.dropComplete(true);
}
 

/**
 * @see java.awt.dnd.DropTargetListener#drop(java.awt.dnd.DropTargetDropEvent)
 */
public void drop(DropTargetDropEvent dtde) {
    try {
       File fileToOpen = DropedFileExtractor.getFile(dtde, _session.getApplication());

       if (fileToOpen != null) {
            if (s_log.isInfoEnabled()) {
                s_log.info("drop: path="+fileToOpen.getAbsolutePath());
            }            
            ISQLPanelAPI api = 
                _session.getSQLPanelAPIOfActiveSessionWindow(); 
            api.fileOpen(fileToOpen);
        }            
    } catch (Exception e) {
        s_log.error("drop: Unexpected exception "+e.getMessage(),e);
    }

}
 

private void doDropAction(final DropTargetDropEvent event) {

        event.acceptDrop(DnDConstants.ACTION_COPY);

        final Optional<File> file = getDroppedFile(event.getTransferable());
        if (file.isPresent()) {
            doFileAction(file.get());
        } else {
            MagicSound.ALERT.play();
        }

        // Inform that the drop is complete
        event.dropComplete(true);
    }
 

@Override public void drop(DropTargetDropEvent e) {
  DefaultListModel<E> model = (DefaultListModel<E>) getModel();
  // Transferable t = e.getTransferable();
  // DataFlavor[] f = t.getTransferDataFlavors();
  // try {
  //   Component comp = (Component) t.getTransferData(f[0]);
  // } catch (UnsupportedFlavorException | IOException ex) {
  //   e.dropComplete(false);
  // }
  if (isDropAcceptable(e) && targetIndex >= 0) {
    E str = model.get(draggedIndex);
    if (targetIndex == draggedIndex) {
      setSelectedIndex(targetIndex);
    } else if (targetIndex < draggedIndex) {
      model.remove(draggedIndex);
      model.add(targetIndex, str);
      setSelectedIndex(targetIndex);
    } else {
      model.add(targetIndex, str);
      model.remove(draggedIndex);
      setSelectedIndex(targetIndex - 1);
    }
    e.dropComplete(true);
  } else {
    e.dropComplete(false);
  }
  e.dropComplete(false);
  targetIndex = -1;
  repaint();
}
 

@Override
public void drop(final DropTargetDropEvent dtde) {

    BiConsumer<Graph, DropInfo> dropHandler = null;

    // Accept the drop, work out whether any graph dropper will handle it, and if so mark the drop as complete.
    dtde.acceptDrop(dtde.getDropAction());
    final Collection<? extends GraphDropper> droppers = Lookup.getDefault().lookupAll(GraphDropper.class);
    for (final GraphDropper dropper : droppers) {
        dropHandler = dropper.drop(dtde);
        if (dropHandler != null) {
            break;
        }
    }
    dtde.dropComplete(dropHandler != null);

    // If a dropper did provide a handler for this drop event, process it in a new thread, providing it with the information obtained from hit testing the graph for the drop location.
    // (Note this has to be in a new thread because hit testing is done on the EDT, which we need to wait for the results of, but we are already on the EDT).
    if (dropHandler != null) {
        BiConsumer<Graph, DropInfo> resultDropHandler = dropHandler;
        final Thread computeDrop = new Thread(() -> {
            final Vector3f dropGraphLocation = processor.windowToGraphCoordinates(processor.getDisplayCamera(), dropLocation);
            final BlockingQueue<HitState> hitTestQueue = new ArrayBlockingQueue<>(1);
            manager.addOperation(processor.hitTestPoint(dropLocation.x, dropLocation.y, hitTestQueue));
            HitState hitState;
            while (true) {
                try {
                    hitState = hitTestQueue.take();
                    break;
                } catch (InterruptedException ex) {
                    Thread.currentThread().interrupt();
                }
            }
            final DropInfo dropInfo = new DropInfo(dropGraphLocation, hitState.getCurrentHitId(), hitState.getCurrentHitType().equals(HitType.VERTEX), hitState.getCurrentHitType().equals(HitType.TRANSACTION));
            resultDropHandler.accept(graph, dropInfo);
        });
        computeDrop.setName("Graph Renderer Drop Target");
        computeDrop.start();
    }
}
 

/**
 * 
 */
protected MouseEvent createEvent(DropTargetEvent e)
{
	JComponent component = getDropTarget(e);
	Point location = null;
	int action = 0;

	if (e instanceof DropTargetDropEvent)
	{
		location = ((DropTargetDropEvent) e).getLocation();
		action = ((DropTargetDropEvent) e).getDropAction();
	}
	else if (e instanceof DropTargetDragEvent)
	{
		location = ((DropTargetDragEvent) e).getLocation();
		action = ((DropTargetDragEvent) e).getDropAction();
	}

	if (location != null)
	{
		location = convertPoint(location);
		Rectangle r = graphComponent.getViewport().getViewRect();
		location.translate(r.x, r.y);
	}

	// LATER: Fetch state of modifier keys from event or via global
	// key listener using Toolkit.getDefaultToolkit().addAWTEventListener(
	// new AWTEventListener() {...}, AWTEvent.KEY_EVENT_MASK). Problem
	// is the event does not contain the modifier keys and the global
	// handler is not called during drag and drop.
	int mod = (action == TransferHandler.COPY) ? InputEvent.CTRL_MASK : 0;

	return new MouseEvent(component, 0, System.currentTimeMillis(), mod,
			location.x, location.y, 1, false, MouseEvent.BUTTON1);
}
 

public void drop(DropTargetDropEvent dtde) {
	if (draggingComponent == null) {
		dtde.rejectDrop();
	} else {

		if (draggingDefaults) {
			setContents(getDefaultContents());
		} else {
			Point p = dtde.getLocation();
			p = SwingUtilities.convertPoint(
					((DropTarget) dtde.getSource()).getComponent(), p,
					CustomizedToolbar.this);

			String[] contents = getContents(p);
			setContents(contents);
			dtde.acceptDrop(DnDConstants.ACTION_MOVE);
			JComponent theComponent = getComponent(draggingComponent);
			Rectangle r = getLayout().getDestinationMap(
					CustomizedToolbar.this).get(theComponent);
			if (r != null) {
				theComponent.setBounds(r);
			}
			if (hideActiveComponents)
				theComponent.setVisible(true);
		}
	}
	dtde.dropComplete(true);
}
 

@Override
public void drop(DropTargetDropEvent e) {
    Transferable transferable = e.getTransferable();
    DataFlavor[] flavors = transferable.getTransferDataFlavors();
    for (DataFlavor flavor : flavors) {
        if (flavor.isFlavorJavaFileListType()) {
            // this is where we get after dropping a file or directory
            e.acceptDrop(DnDConstants.ACTION_COPY);

            try {
                @SuppressWarnings("unchecked")
                List<File> list = (List<File>) transferable.getTransferData(flavor);
                File file = list.get(0);
                if (file.isFile()) {
                    changeFile(file);
                }
            } catch (UnsupportedFlavorException | IOException ex) {
                ex.printStackTrace();
                e.rejectDrop();
            }
            e.dropComplete(true);
            return;
        }
    }

    // DataFlavor not recognized
    e.rejectDrop();
}
 

@Override
public void drop(DropTargetDropEvent dtde) {
    if (dtde.getTransferable().isDataFlavorSupported(WidgetData.EFFECTFLAVOR)){
       GEffectDropEvent(dtde);
    }else if(dtde.isDataFlavorSupported(WidgetData.FLAVOR)){
        GElementDropEvent(dtde);
    }else{
       dtde.rejectDrop(); 
    }
}
 

void checkImage(DropTargetDropEvent dtde) {
    final Transferable t = dtde.getTransferable();
    if (t.isDataFlavorSupported(DataFlavor.imageFlavor)) {
        dtde.acceptDrop(DnDConstants.ACTION_COPY);
        Image im;
        try {
            im = (Image) t.getTransferData(DataFlavor.imageFlavor);
            System.err.println("getTransferData was successful");
        } catch (Exception e) {
            System.err.println("Can't getTransferData: " + e);
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
            return;
        }

        if (im == null) {
            System.err.println("getTransferData returned null");
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
        } else if (areImagesIdentical(image, im)) {
            dtde.dropComplete(true);
            notifyTransferSuccess(true);
        } else {
            System.err.println("transferred image is different from initial image");
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
        }

    } else {
        System.err.println("imageFlavor is not supported by Transferable");
        dtde.rejectDrop();
        notifyTransferSuccess(false);
    }
}
 

@Override
public void handle(PluginTool tool, Object transferData, DropTargetDropEvent e, DataFlavor f) {

	FileImporterService importer = tool.getService(FileImporterService.class);
	if (importer == null) {
		Msg.showError(this, null, "Could Not Import", "Could not find Importer Service");
		return;
	}

	DomainFolder folder = tool.getProject().getProjectData().getRootFolder();
	doImport(importer, folder, transferData);
}
 

@Override
public void drop(final DropTargetDropEvent dtde) {
    if (!inside) {
        FAILED = true;
        Thread.dumpStack();
    }
    inside = false;
}
 

ImageDropTarget() throws AWTException {
    DropTargetAdapter dropTargetAdapter = new DropTargetAdapter() {
        @Override
        public void drop(DropTargetDropEvent dtde) {
            checkImage(dtde);
            startImageDrag();
        }
    };
    new DropTarget(frame, dropTargetAdapter);
    robot = new Robot();
}
 

void checkImage(DropTargetDropEvent dtde) {
    final Transferable t = dtde.getTransferable();
    if (t.isDataFlavorSupported(DataFlavor.imageFlavor)) {
        dtde.acceptDrop(DnDConstants.ACTION_COPY);
        Image im;
        try {
            im = (Image) t.getTransferData(DataFlavor.imageFlavor);
            System.err.println("getTransferData was successful");
        } catch (Exception e) {
            System.err.println("Can't getTransferData: " + e);
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
            return;
        }

        if (im == null) {
            System.err.println("getTransferData returned null");
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
        } else if (areImagesIdentical(image, im)) {
            dtde.dropComplete(true);
            notifyTransferSuccess(true);
        } else {
            System.err.println("transferred image is different from initial image");
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
        }

    } else {
        System.err.println("imageFlavor is not supported by Transferable");
        dtde.rejectDrop();
        notifyTransferSuccess(false);
    }
}
 

@Override
public void drop(final DropTargetDropEvent dtde) {
    if (!inside) {
        FAILED = true;
        Thread.dumpStack();
    }
    inside = false;
}
 

@Override
public void drop(final DropTargetDropEvent dtde) {
    if (!inside) {
        FAILED = true;
        Thread.dumpStack();
    }
    inside = false;
}
 

ImageDropTarget() throws AWTException {
    DropTargetAdapter dropTargetAdapter = new DropTargetAdapter() {
        @Override
        public void drop(DropTargetDropEvent dtde) {
            checkImage(dtde);
            startImageDrag();
        }
    };
    new DropTarget(frame, dropTargetAdapter);
    robot = new Robot();
}
 

void checkImage(DropTargetDropEvent dtde) {
    final Transferable t = dtde.getTransferable();
    if (t.isDataFlavorSupported(DataFlavor.imageFlavor)) {
        dtde.acceptDrop(DnDConstants.ACTION_COPY);
        Image im;
        try {
            im = (Image) t.getTransferData(DataFlavor.imageFlavor);
            System.err.println("getTransferData was successful");
        } catch (Exception e) {
            System.err.println("Can't getTransferData: " + e);
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
            return;
        }

        if (im == null) {
            System.err.println("getTransferData returned null");
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
        } else if (areImagesIdentical(image, im)) {
            dtde.dropComplete(true);
            notifyTransferSuccess(true);
        } else {
            System.err.println("transferred image is different from initial image");
            dtde.dropComplete(false);
            notifyTransferSuccess(false);
        }

    } else {
        System.err.println("imageFlavor is not supported by Transferable");
        dtde.rejectDrop();
        notifyTransferSuccess(false);
    }
}
 

@Override
public void drop(DropTargetDropEvent dtde) {
    //if(shouldRedispatchDnDToHandle()) {
    if(dragProxying) {
        formDesigner.getHandleLayer().getNewComponentDropListener().drop(dtde);
        dragProxying = false;
        return;
    }
    if(dragop.isStarted()) {
        dragop.end(dtde);
        dragProxying = false;
        return;
    }
}
 

/**
 * Creates a drop target drop event.
 * @param id the event id
 * @param event the Swing event
 */
public WidgetDropTargetDropEvent (long id, DropTargetDropEvent event) {
    this.id = id;
    this.event = event;
    Point location = event.getLocation ();
    x = location.x;
    y = location.y;
}