public BasicTransferable(String plainData,
    String htmlData) 
{
        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");
        }
        this.plainData = plainData;
        this.htmlData = htmlData;
}

 protected String getHTMLData() 
{
        return htmlData;
}

Fetch the data in a text/html format

 protected String getPlainData() 
{
        return plainData;
}

Fetch the data in a text/plain format.

 protected Object getRicherData(DataFlavor flavor) throws UnsupportedFlavorException 
{
        return null;
}

 protected DataFlavor[] getRicherFlavors() 
{
        return null;
}

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.

 public Object getTransferData(DataFlavor flavor) throws IOException, UnsupportedFlavorException 
{
        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 new StringBufferInputStream(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 new StringBufferInputStream(data);
            }
            // fall through to unsupported
        } else if (isStringFlavor(flavor)) {
            String data = getPlainData();
            data = (data == null) ? "" : data;
            return data;
        }
        throw new UnsupportedFlavorException(flavor);
}

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.

 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 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).

 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 whether or not the specified data flavor is supported for this object.

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

Returns whether or not the specified data flavor is an HTML flavor that is supported.

 protected boolean isHTMLSupported() 
{
        return htmlData != null;
}

Should the HTML flavors be offered? If so, the method getHTMLData should be implemented to provide something reasonable.

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

Returns whether or not the specified data flavor is an plain flavor that is supported.

 protected boolean isPlainSupported() 
{
        return plainData != null;
}

Should the plain text flavors be offered? If so, the method getPlainData should be implemented to provide something reasonable.

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

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

Returns whether or not the specified data flavor is a String flavor that is supported.