| /* |
| * Copyright (c) 2000, 2002, 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 javax.swing.plaf.basic; |
| |
| import sun.datatransfer.DataFlavorUtil; |
| |
| import java.io.*; |
| import java.awt.datatransfer.*; |
| import javax.swing.plaf.UIResource; |
| |
| /** |
| * A transferable implementation for the default data transfer of some Swing |
| * components. |
| * |
| * @author Timothy Prinzing |
| */ |
| class BasicTransferable implements Transferable, UIResource { |
| |
| protected String plainData; |
| protected String htmlData; |
| |
| private static DataFlavor[] htmlFlavors; |
| private static DataFlavor[] stringFlavors; |
| private static DataFlavor[] plainFlavors; |
| |
| static { |
| try { |
| htmlFlavors = new DataFlavor[3]; |
| htmlFlavors[0] = new DataFlavor("text/html;class=java.lang.String"); |
| htmlFlavors[1] = new DataFlavor("text/html;class=java.io.Reader"); |
| htmlFlavors[2] = new DataFlavor("text/html;charset=unicode;class=java.io.InputStream"); |
| |
| plainFlavors = new DataFlavor[3]; |
| plainFlavors[0] = new DataFlavor("text/plain;class=java.lang.String"); |
| plainFlavors[1] = new DataFlavor("text/plain;class=java.io.Reader"); |
| plainFlavors[2] = new DataFlavor("text/plain;charset=unicode;class=java.io.InputStream"); |
| |
| stringFlavors = new DataFlavor[2]; |
| stringFlavors[0] = new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType+";class=java.lang.String"); |
| stringFlavors[1] = DataFlavor.stringFlavor; |
| |
| } catch (ClassNotFoundException cle) { |
| System.err.println("error initializing javax.swing.plaf.basic.BasicTranserable"); |
| } |
| } |
| |
| public BasicTransferable(String plainData, String htmlData) { |
| this.plainData = plainData; |
| this.htmlData = htmlData; |
| } |
| |
| |
| /** |
| * Returns an array of DataFlavor objects indicating the flavors the data |
| * can be provided in. The array should be ordered according to preference |
| * for providing the data (from most richly descriptive to least descriptive). |
| * @return an array of data flavors in which this data can be transferred |
| */ |
| public DataFlavor[] getTransferDataFlavors() { |
| DataFlavor[] richerFlavors = getRicherFlavors(); |
| int nRicher = (richerFlavors != null) ? richerFlavors.length : 0; |
| int nHTML = (isHTMLSupported()) ? htmlFlavors.length : 0; |
| int nPlain = (isPlainSupported()) ? plainFlavors.length: 0; |
| int nString = (isPlainSupported()) ? stringFlavors.length : 0; |
| int nFlavors = nRicher + nHTML + nPlain + nString; |
| DataFlavor[] flavors = new DataFlavor[nFlavors]; |
| |
| // fill in the array |
| int nDone = 0; |
| if (nRicher > 0) { |
| System.arraycopy(richerFlavors, 0, flavors, nDone, nRicher); |
| nDone += nRicher; |
| } |
| if (nHTML > 0) { |
| System.arraycopy(htmlFlavors, 0, flavors, nDone, nHTML); |
| nDone += nHTML; |
| } |
| if (nPlain > 0) { |
| System.arraycopy(plainFlavors, 0, flavors, nDone, nPlain); |
| nDone += nPlain; |
| } |
| if (nString > 0) { |
| System.arraycopy(stringFlavors, 0, flavors, nDone, nString); |
| nDone += nString; |
| } |
| return flavors; |
| } |
| |
| /** |
| * Returns whether or not the specified data flavor is supported for |
| * this object. |
| * @param flavor the requested flavor for the data |
| * @return boolean indicating whether or not the data flavor is supported |
| */ |
| public boolean isDataFlavorSupported(DataFlavor flavor) { |
| DataFlavor[] flavors = getTransferDataFlavors(); |
| for (int i = 0; i < flavors.length; i++) { |
| if (flavors[i].equals(flavor)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns an object which represents the data to be transferred. The class |
| * of the object returned is defined by the representation class of the flavor. |
| * |
| * @param flavor the requested flavor for the data |
| * @see DataFlavor#getRepresentationClass |
| * @exception IOException if the data is no longer available |
| * in the requested flavor. |
| * @exception UnsupportedFlavorException if the requested data flavor is |
| * not supported. |
| */ |
| public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException { |
| DataFlavor[] richerFlavors = getRicherFlavors(); |
| if (isRicherFlavor(flavor)) { |
| return getRicherData(flavor); |
| } else if (isHTMLFlavor(flavor)) { |
| String data = getHTMLData(); |
| data = (data == null) ? "" : data; |
| if (String.class.equals(flavor.getRepresentationClass())) { |
| return data; |
| } else if (Reader.class.equals(flavor.getRepresentationClass())) { |
| return new StringReader(data); |
| } else if (InputStream.class.equals(flavor.getRepresentationClass())) { |
| return createInputStream(flavor, data); |
| } |
| // fall through to unsupported |
| } else if (isPlainFlavor(flavor)) { |
| String data = getPlainData(); |
| data = (data == null) ? "" : data; |
| if (String.class.equals(flavor.getRepresentationClass())) { |
| return data; |
| } else if (Reader.class.equals(flavor.getRepresentationClass())) { |
| return new StringReader(data); |
| } else if (InputStream.class.equals(flavor.getRepresentationClass())) { |
| return createInputStream(flavor, data); |
| } |
| // fall through to unsupported |
| |
| } else if (isStringFlavor(flavor)) { |
| String data = getPlainData(); |
| data = (data == null) ? "" : data; |
| return data; |
| } |
| throw new UnsupportedFlavorException(flavor); |
| } |
| |
| private InputStream createInputStream(DataFlavor flavor, String data) |
| throws IOException, UnsupportedFlavorException { |
| String cs = DataFlavorUtil.getTextCharset(flavor); |
| if (cs == null) { |
| throw new UnsupportedFlavorException(flavor); |
| } |
| return new ByteArrayInputStream(data.getBytes(cs)); |
| } |
| |
| // --- richer subclass flavors ---------------------------------------------- |
| |
| protected boolean isRicherFlavor(DataFlavor flavor) { |
| DataFlavor[] richerFlavors = getRicherFlavors(); |
| int nFlavors = (richerFlavors != null) ? richerFlavors.length : 0; |
| for (int i = 0; i < nFlavors; i++) { |
| if (richerFlavors[i].equals(flavor)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Some subclasses will have flavors that are more descriptive than HTML |
| * or plain text. If this method returns a non-null value, it will be |
| * placed at the start of the array of supported flavors. |
| */ |
| protected DataFlavor[] getRicherFlavors() { |
| return null; |
| } |
| |
| protected Object getRicherData(DataFlavor flavor) throws UnsupportedFlavorException { |
| return null; |
| } |
| |
| // --- html flavors ---------------------------------------------------------- |
| |
| /** |
| * Returns whether or not the specified data flavor is an HTML flavor that |
| * is supported. |
| * @param flavor the requested flavor for the data |
| * @return boolean indicating whether or not the data flavor is supported |
| */ |
| protected boolean isHTMLFlavor(DataFlavor flavor) { |
| DataFlavor[] flavors = htmlFlavors; |
| for (int i = 0; i < flavors.length; i++) { |
| if (flavors[i].equals(flavor)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Should the HTML flavors be offered? If so, the method |
| * getHTMLData should be implemented to provide something reasonable. |
| */ |
| protected boolean isHTMLSupported() { |
| return htmlData != null; |
| } |
| |
| /** |
| * Fetch the data in a text/html format |
| */ |
| protected String getHTMLData() { |
| return htmlData; |
| } |
| |
| // --- plain text flavors ---------------------------------------------------- |
| |
| /** |
| * Returns whether or not the specified data flavor is an plain flavor that |
| * is supported. |
| * @param flavor the requested flavor for the data |
| * @return boolean indicating whether or not the data flavor is supported |
| */ |
| protected boolean isPlainFlavor(DataFlavor flavor) { |
| DataFlavor[] flavors = plainFlavors; |
| for (int i = 0; i < flavors.length; i++) { |
| if (flavors[i].equals(flavor)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Should the plain text flavors be offered? If so, the method |
| * getPlainData should be implemented to provide something reasonable. |
| */ |
| protected boolean isPlainSupported() { |
| return plainData != null; |
| } |
| |
| /** |
| * Fetch the data in a text/plain format. |
| */ |
| protected String getPlainData() { |
| return plainData; |
| } |
| |
| // --- string flavorss -------------------------------------------------------- |
| |
| /** |
| * Returns whether or not the specified data flavor is a String flavor that |
| * is supported. |
| * @param flavor the requested flavor for the data |
| * @return boolean indicating whether or not the data flavor is supported |
| */ |
| protected boolean isStringFlavor(DataFlavor flavor) { |
| DataFlavor[] flavors = stringFlavors; |
| for (int i = 0; i < flavors.length; i++) { |
| if (flavors[i].equals(flavor)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| |
| } |