private static final long serialVersionUID = 8367026044764648243L;

private static final Class<InputStream> ioInputStreamClass = InputStream.class;

/**

protected final static Class<?> tryToLoadClass(String className,

ClassLoader fallback)

throws ClassNotFoundException

{

ReflectUtil.checkPackageAccess(className);

try {

SecurityManager sm = System.getSecurityManager();

if (sm != null) {

sm.checkPermission(GET_CLASSLOADER_PERMISSION);

}

ClassLoader loader = ClassLoader.getSystemClassLoader();

try {

// bootstrap class loader and system class loader if present

return Class.forName(className, true, loader);

}

catch (ClassNotFoundException exception) {

// thread context class loader if and only if present

loader = Thread.currentThread().getContextClassLoader();

if (loader != null) {

try {

return Class.forName(className, true, loader);

}

catch (ClassNotFoundException e) {

// fallback to user's class loader

}

}

}

} catch (SecurityException exception) {

// ignore secured class loaders

}

return Class.forName(className, true, fallback);

}

/*

static private DataFlavor createConstant(Class<?> rc, String prn) {

try {

return new DataFlavor(rc, prn);

} catch (Exception e) {

return null;

}

}

/*

static private DataFlavor createConstant(String mt, String prn) {

try {

return new DataFlavor(mt, prn);

} catch (Exception e) {

return null;

}

}

/*

static private DataFlavor initHtmlDataFlavor(String htmlFlavorType) {

try {

return new DataFlavor ("text/html; class=java.lang.String;document=" +

htmlFlavorType + ";charset=Unicode");

} catch (Exception e) {

return null;

}

}

/**

public static final DataFlavor stringFlavor = createConstant(java.lang.String.class, "Unicode String");

/**

public static final DataFlavor imageFlavor = createConstant("image/x-java-image; class=java.awt.Image", "Image");

/**

@Deprecated

public static final DataFlavor plainTextFlavor = createConstant("text/plain; charset=unicode; class=java.io.InputStream", "Plain Text");

/**

public static final String javaSerializedObjectMimeType = "application/x-java-serialized-object";

/**

public static final DataFlavor javaFileListFlavor = createConstant("application/x-java-file-list;class=java.util.List", null);

/**

public static final String javaJVMLocalObjectMimeType = "application/x-java-jvm-local-objectref";

/**

public static final String javaRemoteObjectMimeType = "application/x-java-remote-object";

/**

public static DataFlavor selectionHtmlFlavor = initHtmlDataFlavor("selection");

/**

public static DataFlavor fragmentHtmlFlavor = initHtmlDataFlavor("fragment");

/**

public static DataFlavor allHtmlFlavor = initHtmlDataFlavor("all");

/**

public DataFlavor() {

super();

}

/**

private DataFlavor(String primaryType, String subType, MimeTypeParameterList params, Class<?> representationClass, String humanPresentableName) {

super();

if (primaryType == null) {

throw new NullPointerException("primaryType");

}

if (subType == null) {

throw new NullPointerException("subType");

}

if (representationClass == null) {

throw new NullPointerException("representationClass");

}

if (params == null) params = new MimeTypeParameterList();

params.set("class", representationClass.getName());

if (humanPresentableName == null) {

humanPresentableName = params.get("humanPresentableName");

if (humanPresentableName == null)

humanPresentableName = primaryType + "/" + subType;

}

try {

mimeType = new MimeType(primaryType, subType, params);

} catch (MimeTypeParseException mtpe) {

throw new IllegalArgumentException("MimeType Parse Exception: " + mtpe.getMessage());

}

this.representationClass = representationClass;

this.humanPresentableName = humanPresentableName;

mimeType.removeParameter("humanPresentableName");

}

/**

public DataFlavor(Class<?> representationClass, String humanPresentableName) {

this("application", "x-java-serialized-object", null, representationClass, humanPresentableName);

if (representationClass == null) {

throw new NullPointerException("representationClass");

}

}

/**

public DataFlavor(String mimeType, String humanPresentableName) {

super();

if (mimeType == null) {

throw new NullPointerException("mimeType");

}

try {

initialize(mimeType, humanPresentableName, this.getClass().getClassLoader());

} catch (MimeTypeParseException mtpe) {

throw new IllegalArgumentException("failed to parse:" + mimeType);

} catch (ClassNotFoundException cnfe) {

throw new IllegalArgumentException("can't find specified class: " + cnfe.getMessage());

}

}

/**

public DataFlavor(String mimeType, String humanPresentableName, ClassLoader classLoader) throws ClassNotFoundException {

super();

if (mimeType == null) {

throw new NullPointerException("mimeType");

}

try {

initialize(mimeType, humanPresentableName, classLoader);

} catch (MimeTypeParseException mtpe) {

throw new IllegalArgumentException("failed to parse:" + mimeType);

}

}

/**

public DataFlavor(String mimeType) throws ClassNotFoundException {

super();

if (mimeType == null) {

throw new NullPointerException("mimeType");

}

try {

initialize(mimeType, null, this.getClass().getClassLoader());

} catch (MimeTypeParseException mtpe) {

throw new IllegalArgumentException("failed to parse:" + mimeType);

}

}

/**

private void initialize(String mimeType, String humanPresentableName, ClassLoader classLoader) throws MimeTypeParseException, ClassNotFoundException {

if (mimeType == null) {

throw new NullPointerException("mimeType");

}

this.mimeType = new MimeType(mimeType); // throws

String rcn = getParameter("class");

if (rcn == null) {

if ("application/x-java-serialized-object".equals(this.mimeType.getBaseType()))

throw new IllegalArgumentException("no representation class specified for:" + mimeType);

else

representationClass = java.io.InputStream.class; // default

} else { // got a class name

representationClass = DataFlavor.tryToLoadClass(rcn, classLoader);

}

this.mimeType.setParameter("class", representationClass.getName());

if (humanPresentableName == null) {

humanPresentableName = this.mimeType.getParameter("humanPresentableName");

if (humanPresentableName == null)

humanPresentableName = this.mimeType.getPrimaryType() + "/" + this.mimeType.getSubType();

}

this.humanPresentableName = humanPresentableName; // set it.

this.mimeType.removeParameter("humanPresentableName"); // just in case

}

/**

public String toString() {

String string = getClass().getName();

string += "["+paramString()+"]";

return string;

}

private String paramString() {

String params = "";

params += "mimetype=";

if (mimeType == null) {

params += "null";

} else {

params += mimeType.getBaseType();

}

params += ";representationclass=";

if (representationClass == null) {

params += "null";

} else {

params += representationClass.getName();

}

if (DataTransferer.isFlavorCharsetTextType(this) &&

(isRepresentationClassInputStream() ||

isRepresentationClassByteBuffer() ||

DataTransferer.byteArrayClass.equals(representationClass)))

{

params += ";charset=" + DataTransferer.getTextCharset(this);

}

return params;

}

/**

public static final DataFlavor getTextPlainUnicodeFlavor() {

String encoding = null;

DataTransferer transferer = DataTransferer.getInstance();

if (transferer != null) {

encoding = transferer.getDefaultUnicodeEncoding();

}

return new DataFlavor(

"text/plain;charset="+encoding

+";class=java.io.InputStream", "Plain Text");

}

/**

public static final DataFlavor selectBestTextFlavor(

DataFlavor[] availableFlavors) {

if (availableFlavors == null || availableFlavors.length == 0) {

return null;

}

if (textFlavorComparator == null) {

textFlavorComparator = new TextFlavorComparator();

}

DataFlavor bestFlavor =

(DataFlavor)Collections.max(Arrays.asList(availableFlavors),

textFlavorComparator);

if (!bestFlavor.isFlavorTextType()) {

return null;

}

return bestFlavor;

}

private static Comparator<DataFlavor> textFlavorComparator;

static class TextFlavorComparator

extends DataTransferer.DataFlavorComparator {

/**

public int compare(Object obj1, Object obj2) {

DataFlavor flavor1 = (DataFlavor)obj1;

DataFlavor flavor2 = (DataFlavor)obj2;

if (flavor1.isFlavorTextType()) {

if (flavor2.isFlavorTextType()) {

return super.compare(obj1, obj2);

} else {

return 1;

}

} else if (flavor2.isFlavorTextType()) {

return -1;

} else {

return 0;

}

}

}

/**

public Reader getReaderForText(Transferable transferable)

throws UnsupportedFlavorException, IOException

{

Object transferObject = transferable.getTransferData(this);

if (transferObject == null) {

throw new IllegalArgumentException

("getTransferData() returned null");

}

if (transferObject instanceof Reader) {

return (Reader)transferObject;

} else if (transferObject instanceof String) {

return new StringReader((String)transferObject);

} else if (transferObject instanceof CharBuffer) {

CharBuffer buffer = (CharBuffer)transferObject;

int size = buffer.remaining();

char[] chars = new char[size];

buffer.get(chars, 0, size);

return new CharArrayReader(chars);

} else if (transferObject instanceof char[]) {

return new CharArrayReader((char[])transferObject);

}

InputStream stream = null;

if (transferObject instanceof InputStream) {

stream = (InputStream)transferObject;

} else if (transferObject instanceof ByteBuffer) {

ByteBuffer buffer = (ByteBuffer)transferObject;

int size = buffer.remaining();

byte[] bytes = new byte[size];

buffer.get(bytes, 0, size);

stream = new ByteArrayInputStream(bytes);

} else if (transferObject instanceof byte[]) {

stream = new ByteArrayInputStream((byte[])transferObject);

}

if (stream == null) {

throw new IllegalArgumentException("transfer data is not Reader, String, CharBuffer, char array, InputStream, ByteBuffer, or byte array");

}

String encoding = getParameter("charset");

return (encoding == null)

? new InputStreamReader(stream)

: new InputStreamReader(stream, encoding);

}

/**

public String getMimeType() {

return (mimeType != null) ? mimeType.toString() : null;

}

/**

public Class<?> getRepresentationClass() {

return representationClass;

}

/**

public String getHumanPresentableName() {

return humanPresentableName;

}

/**

public String getPrimaryType() {

return (mimeType != null) ? mimeType.getPrimaryType() : null;

}

/**

public String getSubType() {

return (mimeType != null) ? mimeType.getSubType() : null;

}

/**

public String getParameter(String paramName) {

if (paramName.equals("humanPresentableName")) {

return humanPresentableName;

} else {

return (mimeType != null)

? mimeType.getParameter(paramName) : null;

}

}

/**

public void setHumanPresentableName(String humanPresentableName) {

this.humanPresentableName = humanPresentableName;

}

/**

public boolean equals(Object o) {

return ((o instanceof DataFlavor) && equals((DataFlavor)o));

}

/**

public boolean equals(DataFlavor that) {

if (that == null) {

return false;

}

if (this == that) {

return true;

}

if (representationClass == null) {

if (that.getRepresentationClass() != null) {

return false;

}

} else {

if (!representationClass.equals(that.getRepresentationClass())) {

return false;

}