/*
* Copyright (c) 2000, 2005, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.awt.datatransfer;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
* Reads all of the data from the system Clipboard which the data transfer
* subsystem knows how to translate. This includes all text data, File Lists,
* Serializable objects, Remote objects, and properly registered, arbitrary
* data as InputStreams. The data is stored in byte format until requested
* by client code. At that point, the data is converted, if necessary, into
* the proper format to deliver to the application.
*
* This hybrid pre-fetch/delayed-rendering approach allows us to circumvent
* the API restriction that client code cannot lock the Clipboard to discover
* its formats before requesting data in a particular format, while avoiding
* the overhead of fully rendering all data ahead of time.
*
* @author David Mendenhall
* @author Danila Sinopalnikov
*
* @since 1.4 (appeared in modified form as FullyRenderedTransferable in 1.3.1)
*/
public class ClipboardTransferable implements Transferable {
private final HashMap flavorsToData = new HashMap();
private DataFlavor[] flavors = new DataFlavor[0];
private final class DataFactory {
final long format;
final byte[] data;
DataFactory(long format, byte[] data) {
this.format = format;
this.data = data;
}
public Object getTransferData(DataFlavor flavor) throws IOException {
return DataTransferer.getInstance().
translateBytes(data, flavor, format,
ClipboardTransferable.this);
}
}
public ClipboardTransferable(SunClipboard clipboard) {
clipboard.openClipboard(null);
try {
long[] formats = clipboard.getClipboardFormats();
if (formats != null && formats.length > 0) {
// Since the SystemFlavorMap will specify many DataFlavors
// which map to the same format, we should cache data as we
// read it.
HashMap cached_data = new HashMap(formats.length, 1.0f);
Map flavorsForFormats = DataTransferer.getInstance().
getFlavorsForFormats(formats, SunClipboard.flavorMap);
for (Iterator iter = flavorsForFormats.keySet().iterator();
iter.hasNext(); )
{
DataFlavor flavor = (DataFlavor)iter.next();
Long lFormat = (Long)flavorsForFormats.get(flavor);
fetchOneFlavor(clipboard, flavor, lFormat, cached_data);
}
flavors = DataTransferer.getInstance().
setToSortedDataFlavorArray(flavorsToData.keySet(),
flavorsForFormats);
}
} finally {
clipboard.closeClipboard();
}
}
private boolean fetchOneFlavor(SunClipboard clipboard, DataFlavor flavor,
Long lFormat, HashMap cached_data)
{
if (!flavorsToData.containsKey(flavor)) {
long format = lFormat.longValue();
Object data = null;
if (!cached_data.containsKey(lFormat)) {
try {
data = clipboard.getClipboardData(format);
} catch (IOException e) {
data = e;
} catch (Throwable e) {
e.printStackTrace();
}
// Cache this data, even if it's null, so we don't have to go
// to native code again for this format.
cached_data.put(lFormat, data);
} else {
data = cached_data.get(lFormat);
}
// Casting IOException to byte array causes ClassCastException.
// We should handle IOException separately - do not wrap them into
// DataFactory and report failure.
if (data instanceof IOException) {
flavorsToData.put(flavor, data);
return false;
} else if (data != null) {
flavorsToData.put(flavor, new DataFactory(format,
(byte[])data));
return true;
}
}
return false;
}
public DataFlavor[] getTransferDataFlavors() {
return (DataFlavor[])flavors.clone();
}
public boolean isDataFlavorSupported(DataFlavor flavor) {
return flavorsToData.containsKey(flavor);
}
public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException, IOException
{
if (!isDataFlavorSupported(flavor)) {
throw new UnsupportedFlavorException(flavor);
}
Object ret = flavorsToData.get(flavor);
if (ret instanceof IOException) {
// rethrow IOExceptions generated while fetching data
throw (IOException)ret;
} else if (ret instanceof DataFactory) {
// Now we can render the data
DataFactory factory = (DataFactory)ret;
ret = factory.getTransferData(flavor);
}
return ret;
}
}