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

protected void lostOwnershipNow(final AppContext disposedContext) {
    final SunClipboard sunClipboard = SunClipboard.this;
    ClipboardOwner owner = null;
    Transferable contents = null;

    synchronized (sunClipboard) {
        final AppContext context = sunClipboard.contentsContext;

        if (context == null) {
            return;
        }

        if (disposedContext == null || context == disposedContext) {
            owner = sunClipboard.owner;
            contents = sunClipboard.contents;
            sunClipboard.contentsContext = null;
            sunClipboard.owner = null;
            sunClipboard.contents = null;
            sunClipboard.clearNativeContext();
            context.removePropertyChangeListener
                    (AppContext.DISPOSED_PROPERTY_NAME, sunClipboard);
        } else {
            return;
        }
    }
    if (owner != null) {
        owner.lostOwnership(sunClipboard, contents);
    }
}

public Transferable paste() throws IOException {
    if (targetFolder != null) {
        for (Iterator iterator = sourceDataObjects.iterator(); iterator.hasNext();) {
            DataObject dataObject = (DataObject) iterator.next();
            boolean isValid = dataObject != null && dataObject.isValid();

            if (isValid && pasteOperation == LoaderTransfer.CLIPBOARD_COPY) {
                dataObject.createShadow(targetFolder);
            } 

            if (isValid && pasteOperation == LoaderTransfer.CLIPBOARD_CUT) {
                dataObject.move(targetFolder);
            }

        }                
    }
    return null;
}

/** Fills in the list of paste types available for given set to transfered
 * DataObjects.
 * @param t clipboard Transferable object, list of transfered DataObjects with their flavors
 * @param s list of paste types supported for transfered objects
 */
public final void createPasteTypes (Transferable t, java.util.List<PasteType> s) {
    /** All supported operations. */
    int [] ops = defineOperations ();

    for (int i = 0; i < ops.length; i++) {
        DataObject objs [] = LoaderTransfer.getDataObjects (t, ops[i]);
        PasteTypeExt pts [];

        if (objs == null || objs.length == 0)
            continue;

        pts = definePasteTypes (ops[i]);

        for (int j = 0; j < pts.length; j++) {
            pts[j].setDataObjects (objs);
            if (pts[j].canPaste ())
                s.add (pts[j]);
        }
    }

    handleCreatePasteTypes (t, s);
}

/**
 * Returns a string stored in the system clipboard.
 */
public static String getClipboardString()
{
    try
    {
        Transferable transferable = Toolkit.getDefaultToolkit().getSystemClipboard().getContents((Object)null);

        if (transferable != null && transferable.isDataFlavorSupported(DataFlavor.stringFlavor))
        {
            return (String)transferable.getTransferData(DataFlavor.stringFlavor);
        }
    }
    catch (Exception var1)
    {
        ;
    }

    return "";
}

/** Wait until clipboard contains string data and returns the text. */
private String getClipboardText() throws Exception {
    Waiter waiter = new Waiter(new Waitable() {

        @Override
        public Object actionProduced(Object obj) {
            Transferable contents = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);
            if (contents == null) {
                return null;
            } else {
                return contents.isDataFlavorSupported(DataFlavor.stringFlavor) ? Boolean.TRUE : null;
            }
        }

        @Override
        public String getDescription() {
            return ("Wait clipboard contains string data");
        }
    });
    waiter.waitAction(null);
    return Toolkit.getDefaultToolkit().getSystemClipboard().
            getContents(null).getTransferData(DataFlavor.stringFlavor).toString();
}

@Override
public Transferable clipboardCopy() throws IOException {
    if (getSaas().getState() != Saas.State.READY) {
        getSaas().toStateReady(true);
        return super.clipboardCopy();
    }
    if (! portAdded) {
        final WsdlSaasPort port = getDefaultPort(getSaas());
        if (port != null) {
            transferable.put(new Single(ConsumerFlavorProvider.PORT_FLAVOR) {
                @Override
                protected Object getData() throws IOException, UnsupportedFlavorException {
                    return port;
                }

            });
        }
        portAdded = true;
    }
    return SaasTransferable.addFlavors(transferable);
}

protected void lostOwnershipNow(final AppContext disposedContext) {
    final SunClipboard sunClipboard = SunClipboard.this;
    ClipboardOwner owner = null;
    Transferable contents = null;

    synchronized (sunClipboard) {
        final AppContext context = sunClipboard.contentsContext;

        if (context == null) {
            return;
        }

        if (disposedContext == null || context == disposedContext) {
            owner = sunClipboard.owner;
            contents = sunClipboard.contents;
            sunClipboard.contentsContext = null;
            sunClipboard.owner = null;
            sunClipboard.contents = null;
            sunClipboard.clearNativeContext();
            context.removePropertyChangeListener
                    (AppContext.DISPOSED_PROPERTY_NAME, sunClipboard);
        } else {
            return;
        }
    }
    if (owner != null) {
        owner.lostOwnership(sunClipboard, contents);
    }
}

private String getBestCharsetForTextFormat(Long lFormat,
    Transferable localeTransferable) throws IOException
{
    String charset = null;
    if (localeTransferable != null &&
        isLocaleDependentTextFormat(lFormat) &&
        localeTransferable.isDataFlavorSupported(javaTextEncodingFlavor))
    {
        try {
            charset = new String(
                (byte[])localeTransferable.getTransferData(javaTextEncodingFlavor),
                "UTF-8"
            );
        } catch (UnsupportedFlavorException cannotHappen) {
        }
    } else {
        charset = getCharsetForTextFormat(lFormat);
    }
    if (charset == null) {
        // Only happens when we have a custom text type.
        charset = getDefaultTextCharset();
    }
    return charset;
}

/** Performs the paste action.
 * @return <code>Transferable</code> which should be inserted into the clipboard after
 * paste action. It can be null, which means that clipboard content
 * should stay the same
 */
public Transferable paste() throws IOException {
    PropertiesStructure ps = ((PropertiesFileEntry)getFileEntry()).getHandler().getStructure();
    String value;
    if (mode == MODE_PASTE_WITH_VALUE) {
        value = item.getValue();
    } else {
        value = "";
    }
    if (ps != null) {
        Element.ItemElem newItem = ps.getItem(item.getKey());
        if (newItem == null) {
            ps.addItem(item.getKey(), value, item.getComment());
        }
        else {
            newItem.setValue(value);
            newItem.setComment(item.getComment());
        }
        if (node != null) {
            node.destroy();
        }
    }

    return null;
}

/**
 * {@inheritDoc}
 */
@Override
protected void exportDone(JComponent source, Transferable data,
                          int action) {
    try {
        if (source instanceof JList && action == MOVE) {
            JList stopList = (JList)source;
            DefaultListModel listModel
                = (DefaultListModel)stopList.getModel();
            for (Object o : (List) data.getTransferData(STOP_FLAVOR)) {
                listModel.removeElement(o);
            }
        }
    } catch (Exception e) {
        logger.warning(e.toString());
    }
}

@Override
public Transferable paste() throws IOException {
    Tab.RP.post(new Runnable () {
        @Override
        public void run() {
            Set<FileObject> fos = new HashSet<FileObject>(files.size());
            for (File f : files) {
                FileObject fo = FileUtil.toFileObject(FileUtil.normalizeFile(f));
                if (fo != null) {
                    fos.add(fo);
                }
            }
            if (!fos.isEmpty()) {
                try {
                    Favorites.getDefault().add(fos.toArray(new FileObject[fos.size()]));
                } catch (DataObjectNotFoundException ex) {
                    Logger.getLogger(FavoritesNode.class.getName()).log(Level.INFO, null, ex);
                }
            }
        }
    });
    return null;
}

public boolean importData(JComponent comp, Transferable t) {
    if (GrammarEditor.theEditor.shouldSave) {
        int answer = JOptionPane.showConfirmDialog(GrammarEditor.theEditor.frame, "Save before opening a new grammar?", null, JOptionPane.YES_NO_CANCEL_OPTION);
        if (answer == JOptionPane.YES_OPTION)
            GrammarEditor.theEditor.save.doClick();
        else if (answer == JOptionPane.CANCEL_OPTION)
            return false;
    }

    File f = null;
    try {
        f = ((List<File>) t.getTransferData(DataFlavor.javaFileListFlavor)).get(0);
        GrammarEditor.theEditor.openGrammar(f);
        return true;
    } catch (Exception ex) {
        JOptionPane.showMessageDialog(GrammarEditor.theEditor.frame, ex.getMessage(), "Can't drag file", JOptionPane.ERROR_MESSAGE);
    }

    return false;
}

@Override
public Transferable createNewTransferable() {
    return new ExTransferable.Single(Competence.dataFlavor) {

        @Override
        protected Object getData() throws IOException, UnsupportedFlavorException {
            String competenceName = PGSupport.getIdentifierFromDialog("Name of competence");
            if (competenceName == null) {
                return null;
            }

            String elementName = PGSupport.getIdentifierFromDialog("Name of competence atom");
            if (elementName == null) {
                return null;
            }
            try {
                return LapElementsFactory.createCompetence(competenceName, elementName);
            } catch (DuplicateNameException ex) {
                throw new FubarException("Creating new competence with only one name, what duplicate?", ex);
            }
        }
    };
}

private void doPaste() {
    Clipboard clip =
        java.awt.Toolkit.getDefaultToolkit().getSystemClipboard();
    try {
        Transferable content = clip.getContents(this);
        if (content == null)
            return;
        String txt =
            content
                .getTransferData(new DataFlavor(String.class, "String"))
                .toString();
        document.replace(
            editor.getSelectionStart(),
            editor.getSelectionEnd() - editor.getSelectionStart(),
            txt,
            editorKit.getInputAttributes());
        //editor.replaceSelection(content.getTransferData(new
        // DataFlavor(String.class, "String")).toString());
        //editor.paste();
        //insertHTML(content.getTransferData(new DataFlavor(String.class,
        // "String")).toString(), editor.getCaretPosition());
        /*
         * Element el =
         * document.getParagraphElement(editor.getCaretPosition());
         * insertTextInElement(el, content.getTransferData(new
         * DataFlavor(String.class, "String")).toString(),
         */

    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

/**
 * downcall into native code
 */

native long createDragSource(Component component,
                             Transferable transferable,
                             InputEvent nativeTrigger,
                             int actions,
                             long[] formats,
                             Map formatMap);

public Transferable drag() throws IOException {
    ExTransferable t = ExTransferable.create( super.drag() );//NodeTransfer.transferable(this, NodeTransfer.DND_MOVE) );

    customizeTransferable( t );
    t.put( createTransferable() );

    return t;
}

/**
 * {@inheritDoc}
 */
@Override
public Transferable createTransferable(JComponent comp) {
    return (comp instanceof JLabel && comp instanceof Draggable)
        ? new ImageSelection((JLabel) comp)
        : null;
}

int getAllowedDropActions(Transferable t) {
    int actions = 0;
    for (Models.CompoundModel m : models) {
        actions |= m.getAllowedDropActions(t);
    }
    return actions;
}

@Override public Transferable clipboardCut() throws IOException {
    DataFolder top = topPackage();
    if (top != null) {
        return top.getNodeDelegate().clipboardCut();
    } else {
        return super.clipboardCut();
    }
}

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

@Override
public Transferable clipboardCut () throws IOException {
    try {
        return new PackageTransferable (this, DnDConstants.ACTION_MOVE);
    } catch (ClassNotFoundException e) {
        throw new AssertionError(e);
    }
}

protected ValueResolver getClipboardResolver(final JEditorPaneOperator txtOper, final Transferable oldClipValue){

    ValueResolver clipboardValueResolver = new ValueResolver(){
        public Object getValue(){
            Transferable newClipValue = txtOper.getToolkit().getSystemClipboard().getContents(txtOper);
            log("newClipValue:"+newClipValue);
            return (newClipValue == oldClipValue) ? Boolean.TRUE : Boolean.FALSE;
        }
    };

    return clipboardValueResolver;
}

/**
 * Counts the number of times that the given transferable has been imported.
 */
protected void updateImportCount(Transferable t) {
  if (lastImported != t) {
    importCount = initialImportCount;
  } else {
    importCount++;
  }

  lastImported = t;
}

@Override
public Transferable createTransferable(PrimitiveData data) {
    if (data == null) {
        return null;
    }
    String actionName = data.classFQN;
    return new NodeTransferable<TriggeredAction>(LapElementsFactory.createAction(actionName));
}

public static String getStringFromClipboard() { 
    String text = null;
    Transferable trf = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null); 
    if (trf != null && trf.isDataFlavorSupported(DataFlavor.stringFlavor)) {
        try {
            text = (String) trf.getTransferData(DataFlavor.stringFlavor);
        }  catch (Exception e) {};
    }
    return text; 
}

@Override
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<>();
        List<DefaultMutableTreeNode> toRemove = new ArrayList<>();
        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
protected Transferable createTransferable(JComponent c) {
    if (selectedIndex != 0) {
        return createItemTransferable(getSelected());
    }
    // Create transferable for creation of new item
    return newItemTransferable;
}

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);
    }
}

/** Determine which paste operations are allowed when a given transferable is in the clipboard.
* Subclasses should override {@link #createPasteTypes}.
*
* @param t the transferable in the clipboard
* @return array of operations that are allowed
*/
public final PasteType[] getPasteTypes(Transferable t) {
    List<PasteType> s = new LinkedList<PasteType>();
    createPasteTypes(t, s);

    return s.toArray(NO_PASTE_TYPES);
}

@Override
public Object translateStream(InputStream str,
                             DataFlavor flavor, long format,
                             Transferable localeTransferable)
    throws IOException
{
    if (format == CF_HTML && flavor.isFlavorTextType()) {
        str = new HTMLCodec(str,
                             EHTMLReadMode.getEHTMLReadMode(flavor));

    }
    return super.translateStream(str, flavor, format,
                                    localeTransferable);

}

/**
 * {@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;
    }
}