java.awt.dnd.DropTargetDragEvent Java Examples

@SuppressWarnings("rawtypes")
public void dragEnter(DropTargetDragEvent e){
	
	Transferable transferable = e.getTransferable();
	DataFlavor[] types = transferable.getTransferDataFlavors();
	
	
       for(DataFlavor type : types){
          try{
             if(type.equals(DataFlavor.javaFileListFlavor)){
           	 e.acceptDrag(DnDConstants.ACTION_COPY);
                Iterator iterator = ((List) transferable.getTransferData(type)).iterator();
                File file = (File) iterator.next();
                
                if(isFileAcceptable(file)){
               	 e.acceptDrag(1);
                }else{
               	 e.rejectDrag();
                }
             }
          }catch (Exception e1){ e1.printStackTrace(); }
       }
}
 

@Override
public final void dragEnter(final DropTargetDragEvent dtde) {
  final Point pt = dtde.getLocation();
  final int action = dtde.getDropAction();
  if (drawImage) {
    paintImage(pt);
  }

  final Transferable transferable = dtde.getTransferable();

  if (!transferable.isDataFlavorSupported(TransferableNode.NODE_FLAVOR)) {
    if (canPerformAction(tree, dtde.getCurrentDataFlavorsAsList().get(0), dtde.getTransferable(),
        action, pt)) {
      dtde.acceptDrag(action);
    } else {
      dtde.rejectDrag();
    }
  } else {
    if (canPerformAction(tree, draggedNode, action, pt)) {
      dtde.acceptDrag(action);
    } else {
      dtde.rejectDrag();
    }
  }
}
 

@Override
public final void dropActionChanged(final DropTargetDragEvent dtde) {
  final Point pt = dtde.getLocation();
  final int action = dtde.getDropAction();
  if (drawImage) {
    paintImage(pt);
  }
  if (draggedNode == null) {
    if (canPerformAction(tree, dtde.getCurrentDataFlavorsAsList().get(0), dtde.getTransferable(),
        action, pt)) {
      dtde.acceptDrag(action);
    } else {
      dtde.rejectDrag();
    }
  } else {
    if (canPerformAction(tree, draggedNode, action, pt)) {
      dtde.acceptDrag(action);
    } else {
      dtde.rejectDrag();
    }
  }
}
 

@Override
public void dragEnter(DropTargetDragEvent dtde) {
    mDragWasAcceptable = isDragAcceptable(dtde);
    if (mDragWasAcceptable) {
        if (mModel.getDragColumn() != null) {
            dtde.acceptDrag(dragEnterColumn(dtde));
            return;
        }
        Row[] rows = mModel.getDragRows();
        if (rows != null && rows.length > 0) {
            dtde.acceptDrag(dragEnterRow(dtde));
            return;
        }
    } else if (mAlternateDragDestination != null) {
        UIUtilities.updateDropTargetDragPointTo(dtde, mAlternateDragDestination);
        mAlternateDragDestination.dragEnter(dtde);
        return;
    }
    dtde.rejectDrag();
}
 

@Override
public void dropActionChanged(DropTargetDragEvent dtde) {
    if (mDragWasAcceptable) {
        Row[] rows;

        if (mModel.getDragColumn() != null) {
            dtde.acceptDrag(dropActionChangedColumn(dtde));
            return;
        }
        rows = mModel.getDragRows();
        if (rows != null && rows.length > 0) {
            dtde.acceptDrag(dropActionChangedRow(dtde));
            return;
        }
    } else if (mAlternateDragDestination != null) {
        UIUtilities.updateDropTargetDragPointTo(dtde, mAlternateDragDestination);
        mAlternateDragDestination.dropActionChanged(dtde);
        return;
    }
    dtde.rejectDrag();
}
 

private static void acceptOrRejectDrag(DropTargetDragEvent dtde) {
    if (dtde.isDataFlavorSupported(DataFlavor.imageFlavor) || dtde.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
        dtde.acceptDrag(DnDConstants.ACTION_COPY);
    } else {
        dtde.rejectDrag();
    }
}
 

@Override
public void dragOver(final DropTargetDragEvent dtde) {
  if (acceptOrRejectDragging(dtde)) {
    dtde.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE);
  } else {
    dtde.rejectDrag();
  }
}
 

@Override
public synchronized void dragOver(DropTargetDragEvent dtde){
    super.dragOver(dtde);
    J2DNiftyView comp = (J2DNiftyView) this.getComponent();
   
    if(dtde.getDropAction() == DnDConstants.ACTION_MOVE 
            && dtde.getTransferable().isDataFlavorSupported(WidgetData.POINTFLAVOR)){
        comp.moveRect(dtde.getLocation().x, dtde.getLocation().y);
       comp.getDDManager().dragAround(dtde.getLocation().x, dtde.getLocation().y);
    }
    
}
 

@Override
public void dragEnter(final DropTargetDragEvent dtde) {
    if (inside) {
        FAILED = true;
        Thread.dumpStack();
    }
    inside = true;
    MOUSE_ENTERED_DT = true;
    try {
        Thread.sleep(10000); // we should have time to leave a component
    } catch (InterruptedException ignored) {
    }
}
 

public void dragOver(DropTargetDragEvent e) {
    if( e.isDataFlavorSupported( buttonDataFlavor ) || e.isDataFlavorSupported( actionDataFlavor ) ) {
        updateDropGesture( e );
        if( !validateDropPosition() ) {
            e.rejectDrag();
        } else {
            e.acceptDrag( DnDConstants.ACTION_COPY_OR_MOVE );
        }
    } else if( e.isDataFlavorSupported( toolbarDataFlavor ) ) {
        e.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE);
    } else {
        e.rejectDrag();
    }
}
 

@Override public void dropActionChanged(DropTargetDragEvent e) {
  // if (isDragAcceptable(e)) {
  //   e.acceptDrag(e.getDropAction());
  // } else {
  //   e.rejectDrag();
  // }
}
 

/** User is starting to drag over us */
public void dragEnter(DropTargetDragEvent dtde) {
    if (!checkConditions(dtde)) {
        dtde.rejectDrag();
    } else {
        lastIndex = comp.locationToIndex(dtde.getLocation());
        cellRenderer.draggingEnter(lastIndex, ids.getDragGestureEvent().getDragOrigin(), dtde.getLocation());
        comp.repaint(comp.getCellBounds(lastIndex, lastIndex));
    }
}
 

@Override
public void dragEnter(final DropTargetDragEvent dtde) {
    if (inside) {
        FAILED = true;
        Thread.dumpStack();
    }
    inside = true;
    MOUSE_ENTERED_DT = true;
    try {
        Thread.sleep(10000); // we should have time to leave a component
    } catch (InterruptedException ignored) {
    }
}
 

/**
 * Called when a drag operation is ongoing, while the mouse pointer is still over the operable part of the drop site
 * for the <code>DropTarget</code> registered with this listener.
 *
 * @param dtde the <code>DropTargetDragEvent</code>
 */

public void dragOver( final DropTargetDragEvent dtde ) {
  final Transferable transferable = dtde.getTransferable();

  for ( int i = 0; i < acceptedFlavors.length; i++ ) {
    final DataFlavor acceptedFlavor = acceptedFlavors[ i ];
    if ( transferable.isDataFlavorSupported( acceptedFlavor ) ) {
      // a transfer from the palette.
      try {
        transferData = transferable.getTransferData( acceptedFlavor );
        position = dtde.getLocation();
        flavor = acceptedFlavor;
        final int result = updateDragOver( dtde );
        if ( result > 0 ) {
          dtde.acceptDrag( DnDConstants.ACTION_COPY );
        } else {
          transferData = null;
          position = null;
          flavor = null;
          dtde.rejectDrag();
        }
        break;
      } catch ( Exception e ) {
        if ( logger.isDebugEnabled() ) {
          logger.debug( "ReportPanel.dragOver ", e ); // NON-NLS
        }
        transferData = null;
        position = null;
        flavor = null;
        dtde.rejectDrag();
      }
    }
  }
}
 

@Override
public void dragEnter(DropTargetDragEvent dtde) {
    mDragWasAcceptable = false;
    try {
        if (dtde.isDataFlavorSupported(RowSelection.DATA_FLAVOR)) {
            Row[] rows = (Row[]) dtde.getTransferable().getTransferData(RowSelection.DATA_FLAVOR);
            if (rows.length > 0) {
                mDragRows = new ArrayList<>(rows.length);

                for (Row element : rows) {
                    if (element instanceof ListRow) {
                        mDragRows.add(element);
                    }
                }
                if (!mDragRows.isEmpty()) {
                    mDragWasAcceptable = true;
                    dtde.acceptDrag(DnDConstants.ACTION_MOVE);
                }
            }
        }
    } catch (Exception exception) {
        Log.error(exception);
    }
    if (!mDragWasAcceptable) {
        dtde.rejectDrag();
    }
}
 

private boolean shouldRedispatchDnDToHandle(DropTargetDragEvent dtde) {
    RADComponent rad = formDesigner.getHandleLayer().getMetaComponentAt(dtde.getLocation(), HandleLayer.COMP_DEEPEST);
    if(rad != null && isMenuRelatedComponentClass(rad.getBeanClass())) {
        return false;
    }
    if(!USE_JSEPARATOR_FIX) return false;
    PaletteItem item = PaletteUtils.getSelectedItem();
    if(item != null && JSeparator.class.isAssignableFrom(item.getComponentClass())) {
        return true;
    }
    return false;
}
 

@Override
public void dragEnter(final DropTargetDragEvent dtde) {
    if (inside) {
        FAILED = true;
        Thread.dumpStack();
    }
    inside = true;
    MOUSE_ENTERED_DT = true;
    try {
        Thread.sleep(10000); // we should have time to leave a component
    } catch (InterruptedException ignored) {
    }
}
 

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

@Override
public void dragOver(DropTargetDragEvent dtde) {
    if (mDragDockable != null) {
        updateForDragOver(dtde.getLocation());
        dtde.acceptDrag(DnDConstants.ACTION_MOVE);
    } else {
        dtde.rejectDrag();
    }
}
 

@Override
public void dragEnter(DropTargetDragEvent dtde) {
	try {
		File file = getFile(dtde.getTransferable());
		if (isZip(file) || isUrl(file)){
			dtde.acceptDrag(DnDConstants.ACTION_LINK);
		} else {
			dtde.rejectDrag();
		}
	} catch (UnsupportedFlavorException | IOException e) {
		e.printStackTrace();
		dtde.rejectDrag();
	}
	listenTo.repaint();
}
 

private static void handleOngoingDrag(DropTargetDragEvent dtde) {
    if (dtde.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
        dtde.acceptDrag(DnDConstants.ACTION_COPY);
    } else {
        dtde.rejectDrag();
    }
}
 

@Override
public void dragUnderFeedback(boolean ok, DropTargetDragEvent e) {
	synchronized (table) {
		int dropAction = e.getDropAction();
		boolean actionChanged = false;
		if (dropAction != lastDndAction) {
			actionChanged = true;
			lastDndAction = dropAction;
		}
		if (table.isEditing()) {
			table.editingCanceled(null);
		}
		boolean inserting = false;
		if (dropAction == DnDConstants.ACTION_COPY) {
			inserting = true;
		}
		dndTableCellRenderer.selectRange(inserting);
		dndDtiCellRenderer.selectRange(inserting);
		Point p = e.getLocation();
		int row = table.rowAtPoint(p);
		boolean setRow = dndTableCellRenderer.setRowForFeedback(row);
		boolean setDtiRow = dndDtiCellRenderer.setRowForFeedback(row);
		if (actionChanged || setRow || setDtiRow) {
			table.repaint();
		}
	}
}
 

@Override
public void dragEnter(final DropTargetDragEvent e) {
	super.dragEnter(e);
	if (dropTragetListenerList != null) {
		Object[] listeners = dropTragetListenerList.getListenerList();
		for (int i = listeners.length - 2; i >= 0; i -= 2) {
			if (listeners[i] == DropTargetListener.class) {
				((DropTargetListener) listeners[i + 1]).dragEnter(e);
			}
		}
	}
}
 

@Override
public void dragOver(@Nonnull final DropTargetDragEvent dtde) {
  if (acceptOrRejectDragging(dtde)) {
    dtde.acceptDrag(DnDConstants.ACTION_MOVE);
  } else {
    dtde.rejectDrag();
  }
  this.scrollPane.repaint();
}
 

@Override
public void dragEnter(final DropTargetDragEvent dtde) {
    if (inside) {
        FAILED = true;
        Thread.dumpStack();
    }
    inside = true;
    MOUSE_ENTERED_DT = true;
    try {
        Thread.sleep(10000); // we should have time to leave a component
    } catch (InterruptedException ignored) {
    }
}
 

private void doDragOver(DropTargetDragEvent dtde) {

		if (acceptDrag(dtde))
			dtde.acceptDrag(dtde.getDropAction());
		else
			dtde.rejectDrag();
	}
 

@Override
public void dragEnter(DropTargetDragEvent e)
{
   if (isDragAcceptable(e))
   {
      e.acceptDrag(e.getDropAction());
   }
   else
   {
      e.rejectDrag();
   }
}
 

@Override
protected boolean isRowDragAcceptable(DropTargetDragEvent dtde, Row[] rows) {
    return !getModel().isLocked() && rows.length > 0 && (rows[0] instanceof Advantage || rows[0] instanceof AdvantageModifier);
}
 

@Override
public void dragEnter(DropTargetDragEvent dtde) {
    handleOngoingDrag(dtde);
}
 

@Override
public void dragEnter(DropTargetDragEvent event) {
}