Java Code Examples for javax.swing.TransferHandler#TransferSupport

@Override
public boolean importData(TransferHandler.TransferSupport support) {
    if (!canImport(support)) {
        return false;
    }
    JTable.DropLocation dl = (JTable.DropLocation) support.getDropLocation();
    JTable table = (JTable) support.getComponent();
    int row = dl.getRow();
    int tcRow = dl.getColumn() - 1;
    if (row == -1) {
        return false;
    }

    Scenario scenario = (Scenario) table.getModel();
    TestCase testCase = scenario.getTestCaseByName(
            table.getValueAt(row, 0).toString());

    if (dropObject instanceof TestCaseDnD) {
        putReusables(testCase, tcRow);
    } else {
        return false;
    }
    return super.importData(support);
}
 

private Boolean importTestCases(List<TestCaseNode> testCaseNodes,
        TransferHandler.TransferSupport ts) {
    Boolean shouldCut = ts.isDrop() ? ts.getDropAction() == MOVE : isCut;
    Object destObject = getDestinationObject(ts);
    ScenarioNode scNode = getScenarioNode(destObject);
    if (scNode != null) {
        copySelectedTestCases(testCaseNodes, scNode, shouldCut);
        return true;
    }
    if (!(destObject instanceof TestPlanNode)
            && destObject instanceof GroupNode) {
        copySelectedTestCases(testCaseNodes, (GroupNode) destObject, shouldCut);
        return true;
    }
    return false;
}
 

@SuppressWarnings("unchecked")
@Override
public boolean importData(TransferHandler.TransferSupport info) {
	if (!info.isDrop())
		return false;
	Transferable t = info.getTransferable();
	List<File> data = null;
	try {
		data = (List<File>) t.getTransferData(DataFlavor.javaFileListFlavor);
	} catch (Exception e) {
		return false;
	}
	user.preLoadJars(id);
	for (File jar : data) {
		if (jar.getName().toLowerCase().endsWith(".jar")) {
			user.onJarLoad(id, jar);
			break;
		}
	}
	return true;
}
 

@Override
public boolean importData(TransferHandler.TransferSupport ts) {
    if (ts.isDataFlavorSupported(TESTCASE_FLAVOR)) {
        try {
            TestCaseDnD testCaseDnD
                    = (TestCaseDnD) ts.getTransferable()
                    .getTransferData(TESTCASE_FLAVOR);
            sourceTreeModel = testCaseDnD.model;
            if (testCaseDnD.isTestCases()) {
                return importTestCases(testCaseDnD.getTestCaseList(), ts);
            } else {
                return importScenarios(testCaseDnD.getScenarioList(), ts);
            }

        } catch (UnsupportedFlavorException | IOException ex) {
            Logger.getLogger(ProjectDnD.class
                    .getName()).log(Level.SEVERE, null, ex);
            return false;
        }

    }
    return false;
}
 

@Override
public boolean importData(TransferHandler.TransferSupport info) {
    JTable target = (JTable) info.getComponent();
    JTable.DropLocation dl = (JTable.DropLocation) info.getDropLocation();
    int dropIndex = dl.getRow();
    int max = table.getModel().getRowCount();
    if (dropIndex < 0 || dropIndex > max) {
        dropIndex = max;
    }
    target.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
    try {
        Integer rowFrom = (Integer) info.getTransferable().getTransferData(localObjectFlavor);
        if (rowFrom != -1 && rowFrom != dropIndex) {
            ((Reorderable)table.getModel()).reorder(rowFrom, dropIndex);
            if (dropIndex > rowFrom) {
                dropIndex--;
            }
            target.getSelectionModel().addSelectionInterval(dropIndex, dropIndex);
            return true;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}
 

@Override
public boolean canImport(TransferHandler.TransferSupport support) {

    if (!support.isDrop()) {
        return false;
    }

    if (!support.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
        return false;
    }


    boolean actionSupported = (MOVE & support.getSourceDropActions()) == MOVE;
    if (!actionSupported) {
        return false;
    }

    support.setDropAction(MOVE);
    return true;
}
 

@SuppressWarnings("unchecked")
@Override
public boolean importData(TransferHandler.TransferSupport info) {
  if (!info.isDrop())
    return false;
  Transferable t = info.getTransferable();
  List<File> data = null;
  try {
    data = (List<File>) t.getTransferData(DataFlavor.javaFileListFlavor);
  } catch (Exception e) {
    return false;
  }
  user.preLoadJars(id);
  for (File jar : data) {
    if (jar.getName().toLowerCase().endsWith(".jar")) {
      user.onJarLoad(id, jar);
      break;
    }
  }
  return true;
}
 

@Override
public boolean importData(final TransferHandler.TransferSupport support) {
    if (!canImport(support)) {
        return false;
    }

    final Transferable transferable = support.getTransferable();
    String indexString;
    try {
        indexString = (String) transferable.getTransferData(DataFlavor.stringFlavor);
    } catch (Exception ex) {
        return false;
    }

    final int index = Integer.parseInt(indexString);
    JList.DropLocation dl = (JList.DropLocation) support.getDropLocation();
    final int dropTargetIndex = dl.getIndex();

    // Drop the dragged element into the correct place.
    if (index < dropTargetIndex) {
        // If the dragged element is being dropped at a higher target index,
        // add the element at the indicated index, remove the element from the source,
        // and select the dragged element (at a different position due to the removal).
        list.model.addMyElement(dropTargetIndex, list.model.getMyElementAt(index));
        list.model.removeMyElement(index);
        list.setSelectedIndex(dropTargetIndex - 1);
    } else {
        // If the dragged element is being dropped at a lower target index,
        // remove the element from the source, add it at the indicated index,
        // and select it.
        final MyElement element = list.model.removeMyElement(index);
        list.model.addMyElement(dropTargetIndex, element);
        list.setSelectedIndex(dropTargetIndex);
    }

    return true;
}
 

@Override
public boolean importData(TransferHandler.TransferSupport support) {
    if (!canImport(support)) {
        return false;
    }
    JTable.DropLocation dl = (JTable.DropLocation) support.getDropLocation();
    JTable table = (JTable) support.getComponent();
    int row = dl.getRow();
    int column = dl.getColumn();

    if (row == -1) {
        return false;
    }

    if (dropObject instanceof ObjectRepDnD) {
        switch (column) {
            case inputColumn:
                putInput(table, row);
                break;
            case conditionColumn:
                putRelativeObject(table, row);
                break;
            default:
                putWebObjects(table, row);
                break;
        }

    } else if (dropObject instanceof TestDataDetail) {
        putTestData(table, row);
    } else if (dropObject instanceof TestCaseDnD) {
        putReusables(table, row);
    } else {
        return false;
    }
    return super.importData(support);
}
 

@Override
public boolean importData(TransferHandler.TransferSupport support) {
    if (!canImport(support)) {
        return false;
    }
    if (support.getTransferable().isDataFlavorSupported(INDICES)) {
        return reorderProjects(support);
    } else {
        return dropProjects(support);
    }
}
 

@Override
public boolean canImport(TransferHandler.TransferSupport support) {
    if (!support.isDrop()) {
        return false;
    }
    support.setShowDropLocation(true);
    if (!support.isDataFlavorSupported(nodesFlavor)) {
        return false;
    }
    // Do not allow a drop on the drag source selections.
    JTree.DropLocation dl = (JTree.DropLocation) support.getDropLocation();
    JTree tree = (JTree) support.getComponent();
    int dropRow = tree.getRowForPath(dl.getPath());
    int[] selRows = tree.getSelectionRows();
    for (int i = 0; i < selRows.length; i++) {
        if (selRows[i] == dropRow) {
            return false;
        }
    }
    // Do not allow MOVE-action drops if a non-leaf node is
    // selected unless all of its children are also selected.
    int action = support.getDropAction();
    if (action == MOVE) {
        return haveCompleteNode(tree);
    }
    // Do not allow a non-leaf node to be copied to a level
    // which is less than its source level.
    TreePath dest = dl.getPath();
    DefaultMutableTreeNode target = (DefaultMutableTreeNode)
            dest.getLastPathComponent();
    TreePath path = tree.getPathForRow(selRows[0]);
    DefaultMutableTreeNode firstNode = (DefaultMutableTreeNode)
            path.getLastPathComponent();
    if (firstNode.getChildCount() > 0
            && target.getLevel() < firstNode.getLevel()) {
        return false;
    }
    return true;
}
 

@Override
public boolean canImport(TransferHandler.TransferSupport support) {
    logger.debug("canImport " + support.getComponent().getClass().getCanonicalName());
    TransferHandler th = getTransferHandlerForSelection(support.getComponent());
    if (th != null) {
        return th.canImport(support);
    }

    return false;
}
 

@Override
public boolean importData(TransferHandler.TransferSupport support) {
    if (canImport(support)) {
        return dropFeature(support);
    }
    return false;
}
 

@Override
public boolean canImport(TransferHandler.TransferSupport support) {
  if (support.isDataFlavorSupported(DataFlavor.javaFileListFlavor)
  		|| (OSPRuntime.isLinux()&&support.isDataFlavorSupported(uriListFlavor))) {
 	if (dropList==null && support.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
 		try {
 			Transferable t = support.getTransferable();
 			dropList = getFileList(t);
 			dropComponent = support.getComponent();
 			dropComponent.getDropTarget().addDropTargetListener(dropListener);
		} catch (Exception ex) {
		} 
 	}
		boolean isImport = false;
 	if (dropList!=null && dropComponent instanceof TrackerPanel) {
     if (dropList.size()==1) {
     	File file = (File)dropList.get(0);
     	if (videoFilter.accept(file)) {
     		isImport = true;
     	}
     }
 	}
    if (!isImport) {
      support.setDropAction(TransferHandler.COPY);
    }
    return true;
  }
  return false;
}
 

@Override
public boolean canImport(TransferHandler.TransferSupport info) {
    boolean b = info.getComponent() == table && info.isDrop() && info.isDataFlavorSupported(localObjectFlavor);
    table.setCursor(b ? DragSource.DefaultMoveDrop : DragSource.DefaultMoveNoDrop);
    return b;
}
 

@Override
public boolean canImport(TransferHandler.TransferSupport info) {

    return true;
}
 

@Override
public boolean canImport(TransferHandler.TransferSupport info) {
    boolean b = info.getComponent() == table && info.isDrop() && info.isDataFlavorSupported(localObjectFlavor);
    table.setCursor(b ? DragSource.DefaultMoveDrop : DragSource.DefaultMoveNoDrop);
    return b;
}
 

@Override
public boolean importData(TransferHandler.TransferSupport support) {
    logger.debug("importData " + support.getComponent().getClass().getCanonicalName());

    if (!support.isDrop()) {
        return false;
    }

    JTree tree = (JTree) support.getComponent();

    ScriptNode dragNode = (ScriptNode) tree.getSelectionPath().getLastPathComponent();

    // Get drop location info.
    JTree.DropLocation dl = (JTree.DropLocation) support.getDropLocation();
    int childIndex = dl.getChildIndex();
    TreePath dest = dl.getPath();
    DefaultMutableTreeNode parent = (DefaultMutableTreeNode) dest.getLastPathComponent();
    boolean cut = (support.getDropAction() & MOVE) == MOVE;

    if (parent.getUserObject() == null) {
        return false;
    } else if (!(parent.getUserObject() instanceof ZestElementWrapper)
            && !(parent.getUserObject() instanceof ZestScriptWrapper)) {
        return false;
    }

    ScriptNode beforeChild = null;
    ScriptNode afterChild = null;

    if (childIndex >= 0) {
        if (childIndex == parent.getChildCount()) {
            afterChild = (ScriptNode) parent.getChildAt(childIndex - 1);
        } else {
            beforeChild = (ScriptNode) parent.getChildAt(childIndex);
        }
    }

    List<ScriptNode> nodes = new ArrayList<ScriptNode>();
    nodes.add(dragNode);

    extension.pasteToNode((ScriptNode) parent, nodes, cut, beforeChild, afterChild);
    return true;
}
 

@Override
public boolean canImport(TransferHandler.TransferSupport info) {
  info.setShowDropLocation(false);
  return info.isDrop() && info.isDataFlavorSupported(DataFlavor.javaFileListFlavor);
}
 

public boolean chainImportData(TransferHandler.TransferSupport support){return false;}