java类java.awt.datatransfer.Transferable的实例源码

/**
 * {@inheritDoc}
 */
@Override
protected void exportDone(JComponent source, Transferable data, 
                          int action) {
    //this.indices = null;
    this.numberOfItems = 0;
    updateAllLists();
}

@Override
public PasteType getDropType(Object node, Transferable t, int action,
                             int index) throws UnknownTypeException {
    if (dndfilter != null) {
        return dndfilter.getDropType(model, node, t, action, index);
    } else {
        return model.getDropType(node, t, action, index);
    }
}

@Override
public Transferable clipboardCopy() throws IOException {
    if (method.getSaas().getState() != Saas.State.READY) {
        method.getSaas().toStateReady(false);
        return super.clipboardCopy();
    }
    return SaasTransferable.addFlavors(transferable);
}

protected Transferable createTransferable(JComponent c) {
    JTree tree = (JTree)c;
    TreePath[] paths = tree.getSelectionPaths();
    if(paths != null) {
        // Make up a node array of copies for transfer and
        // another for/of the nodes that will be removed in
        // exportDone after a successful drop.
        List<DefaultMutableTreeNode> copies =
            new ArrayList<DefaultMutableTreeNode>();
        List<DefaultMutableTreeNode> toRemove =
            new ArrayList<DefaultMutableTreeNode>();
        DefaultMutableTreeNode node =
            (DefaultMutableTreeNode)paths[0].getLastPathComponent();
        DefaultMutableTreeNode copy = copy(node);
        copies.add(copy);
        toRemove.add(node);
        for(int i = 1; i < paths.length; i++) {
            DefaultMutableTreeNode next =
                (DefaultMutableTreeNode)paths[i].getLastPathComponent();
            // Do not allow higher level nodes to be added to list.
            if(next.getLevel() < node.getLevel()) {
                break;
            } else if(next.getLevel() > node.getLevel()) {  // child node
                copy.add(copy(next));
                // node already contains child
            } else {                                        // sibling
                copies.add(copy(next));
                toRemove.add(next);
            }
        }
        DefaultMutableTreeNode[] nodes =
            copies.toArray(new DefaultMutableTreeNode[copies.size()]);
        nodesToRemove =
            toRemove.toArray(new DefaultMutableTreeNode[toRemove.size()]);
        return new NodesTransferable(nodes);
    }
    return null;
}

@Override
public synchronized Transferable getContents(Object requestor) {
    if (contents != null) {
        return contents;
    }
    return new ClipboardTransferable(this);
}

public Transferable createTransferable() {
    exporting = true;
    final int[] is = getSelectedRows();
    final ArrayList<Integer> al = new ArrayList<Integer>();
    Rows rows = new Rows();
    for (final int i : is) {
        al.add(i);
        TreeTableNode node = (TreeTableNode) getPathForRow(i)
                .getLastPathComponent();
        if ((node != null) && (node.getRow() != null))
            rows.add(node.getRow());
    }
    return new ArrayTransferable(al, rows);
}

public synchronized void setContents(Transferable contents,
                                     ClipboardOwner owner) {
    // 4378007 : Toolkit.getSystemClipboard().setContents(null, null)
    // should throw NPE
    if (contents == null) {
        throw new NullPointerException("contents");
    }

    initContext();

    final ClipboardOwner oldOwner = this.owner;
    final Transferable oldContents = this.contents;

    try {
        this.owner = owner;
        this.contents = new TransferableProxy(contents, true);

        setContentsNative(contents);
    } finally {
        if (oldOwner != null && oldOwner != owner) {
            EventQueue.invokeLater(new Runnable() {
                public void run() {
                    oldOwner.lostOwnership(SunClipboard.this, oldContents);
                }
            });
        }
    }
}

private Transferable createTransferable( final Item item ) {
    return new ExTransferable.Single( PaletteController.ITEM_DATA_FLAVOR ) {
        protected Object getData() throws IOException, UnsupportedFlavorException {
            return item.getLookup();
        }
    };
}

protected synchronized void setContentsNative(Transferable contents) {
    SortedMap<Long,DataFlavor> formatMap =
        DataTransferer.getInstance().getFormatsForTransferable
            (contents, DataTransferer.adaptFlavorMap(getDefaultFlavorTable()));
    long[] formats = DataTransferer.keysToLongArray(formatMap);

    if (!selection.setOwner(contents, formatMap, formats,
                            XToolkit.getCurrentServerTime())) {
        this.owner = null;
        this.contents = null;
    }
}

void setDraggedTransferable(Transferable trans, boolean isCut) {
    if (isCut) {
        draggedTransForCut = trans;
    } else {
        draggedTransForCopy = trans;
    }
}