FileDocCategorySizeDatePackage
DataFlavor.javaAPI DocJava SE 5 API51971Fri Aug 26 14:56:48 BST 2005java.awt.datatransfer

DataFlavor

public class DataFlavor extends Object implements Externalizable, Cloneable
Each instance represents the opaque concept of a data format as would appear on a clipboard, during drag and drop, or in a file system.

DataFlavor objects are constant and never change once instantiated.

For information on using data transfer with Swing, see How to Use Drag and Drop and Data Transfer, a section in The Java Tutorial, for more information.

version
1.79, 05/18/04
author
Blake Sullivan
author
Laurence P. G. Cable
author
Jeff Dunn

Fields Summary
private static final long
serialVersionUID
private static final Class
ioInputStreamClass
public static final DataFlavor
stringFlavor
The DataFlavor representing a Java Unicode String class, where: 
representationClass = java.lang.String
mimeType = "application/x-java-serialized-object"
public static final DataFlavor
imageFlavor
The DataFlavor representing a Java Image class, where: 
representationClass = java.awt.Image
mimeType = "image/x-java-image"
public static final DataFlavor
plainTextFlavor
The DataFlavor representing plain text with Unicode encoding, where: 
representationClass = InputStream
mimeType = "text/plain; charset=unicode"
This DataFlavor has been deprecated because (1) Its representation is an InputStream, an 8-bit based representation, while Unicode is a 16-bit character set; and (2) The charset "unicode" is not well-defined. "unicode" implies a particular platform's implementation of Unicode, not a cross-platform implementation.
public static final String
javaSerializedObjectMimeType
A MIME Content-Type of application/x-java-serialized-object represents a graph of Java object(s) that have been made persistent. The representation class associated with this DataFlavor identifies the Java type of an object returned as a reference from an invocation java.awt.datatransfer.getTransferData.
public static final DataFlavor
javaFileListFlavor
To transfer a list of files to/from Java (and the underlying platform) a DataFlavor of this type/subtype and representation class of java.util.List is used. Each element of the list is required/guaranteed to be of type java.io.File.
public static final String
javaJVMLocalObjectMimeType
To transfer a reference to an arbitrary Java object reference that has no associated MIME Content-type, across a Transferable interface WITHIN THE SAME JVM, a DataFlavor with this type/subtype is used, with a representationClass equal to the type of the class/interface being passed across the Transferable.

The object reference returned from Transferable.getTransferData for a DataFlavor with this MIME Content-Type is required to be an instance of the representation Class of the DataFlavor.

public static final String
javaRemoteObjectMimeType
In order to pass a live link to a Remote object via a Drag and Drop ACTION_LINK operation a Mime Content Type of application/x-java-remote-object should be used, where the representation class of the DataFlavor represents the type of the Remote interface to be transferred.
private static Comparator
textFlavorComparator
transient int
atom
MimeType
mimeType
private String
humanPresentableName
private Class
representationClass
Java class of objects this DataFlavor represents
Constructors Summary
public DataFlavor()
Constructs a new DataFlavor. This constructor is provided only for the purpose of supporting the Externalizable interface. It is not intended for public (client) use.

since
1.2


                                       
       
        super();
private DataFlavor(String primaryType, String subType, MimeTypeParameterList params, Class representationClass, String humanPresentableName)
Constructs a fully specified DataFlavor.

exception
NullPointerException if either primaryType, subType or representationClass is null

        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 = (String)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)
Constructs a DataFlavor that represents a Java class.

The returned DataFlavor will have the following characteristics: 

representationClass = representationClass
mimeType = application/x-java-serialized-object

param
representationClass the class used to transfer data in this flavor
param
humanPresentableName the human-readable string used to identify this flavor; if this parameter is null then the value of the the MIME Content Type is used
exception
NullPointerException if representationClass is null

        this("application", "x-java-serialized-object", null, representationClass, humanPresentableName);
        if (representationClass == null) {
            throw new NullPointerException("representationClass");
        }
public DataFlavor(String mimeType, String humanPresentableName)
Constructs a DataFlavor that represents a MimeType.

The returned DataFlavor will have the following characteristics:

If the mimeType is "application/x-java-serialized-object; class=<representation class>", the result is the same as calling new DataFlavor(Class:forName(<representation class>).

Otherwise: 

representationClass = InputStream
mimeType = mimeType

param
mimeType the string used to identify the MIME type for this flavor; if the the mimeType does not specify a "class=" parameter, or if the class is not successfully loaded, then an IllegalArgumentException is thrown
param
humanPresentableName the human-readable string used to identify this flavor; if this parameter is null then the value of the the MIME Content Type is used
exception
IllegalArgumentException if mimeType is invalid or if the class is not successfully loaded
exception
NullPointerException if mimeType is null

        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)
Constructs a DataFlavor that represents a MimeType.

The returned DataFlavor will have the following characteristics:

If the mimeType is "application/x-java-serialized-object; class=<representation class>", the result is the same as calling new DataFlavor(Class:forName(<representation class>).

Otherwise: 

representationClass = InputStream
mimeType = mimeType

param
mimeType the string used to identify the MIME type for this flavor
param
humanPresentableName the human-readable string used to identify this flavor
param
classLoader the class loader to use
exception
ClassNotFoundException if the class is not loaded
exception
IllegalArgumentException if mimeType is invalid
exception
NullPointerException if mimeType is null

	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)
Constructs a DataFlavor from a mimeType string. The string can specify a "class=" parameter to create a DataFlavor with the desired representation class. If the string does not contain "class=" parameter, java.io.InputStream is used as default.

param
mimeType the string used to identify the MIME type for this flavor; if the class specified by "class=" parameter is not successfully loaded, then an ClassNotFoundException is thrown
exception
ClassNotFoundException if the class is not loaded
exception
IllegalArgumentException if mimeType is invalid
exception
NullPointerException if mimeType is null

        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);
        }
Methods Summary
public java.lang.Objectclone()
Returns a clone of this DataFlavor.

return
a clone of this DataFlavor

	Object newObj = super.clone();
	if (mimeType != null) {
	    ((DataFlavor)newObj).mimeType = (MimeType)mimeType.clone();
	}
	return newObj;
private static java.awt.datatransfer.DataFlavorcreateConstant(java.lang.Class rc, java.lang.String prn)

        try {
            return new DataFlavor(rc, prn);
        } catch (Exception e) {
            return null;
        }
private static java.awt.datatransfer.DataFlavorcreateConstant(java.lang.String mt, java.lang.String prn)

        try {
            return new DataFlavor(mt, prn);
        } catch (Exception e) {
            return null;
        }
public booleanequals(java.lang.Object o)
Tests an arbitrary Object to this DataFlavor for equality. Two DataFlavors are considered equal if and only if their MIME primary type and subtype and representation class are equal. Additionally, if the primary type is "text", the subtype denotes a text flavor which supports the charset parameter, and the representation class is not java.io.Reader, java.lang.String, java.nio.CharBuffer, or [C, the charset parameter must also be equal. If a charset is not explicitly specified for one or both DataFlavors, the platform default encoding is assumed. See selectBestTextFlavor for a list of text flavors which support the charset parameter.

param
o the Object to compare with this
return
true if that is equivalent to this DataFlavor; false otherwise
see
#selectBestTextFlavor

        return ((o instanceof DataFlavor) && equals((DataFlavor)o));
public booleanequals(java.awt.datatransfer.DataFlavor that)
Tests a DataFlavor to this DataFlavor for equality. Two DataFlavors are considered equal if and only if their MIME primary type and subtype and representation class are equal. Additionally, if the primary type is "text", the subtype denotes a text flavor which supports the charset parameter, and the representation class is not java.io.Reader, java.lang.String, java.nio.CharBuffer, or [C, the charset parameter must also be equal. If a charset is not explicitly specified for one or both DataFlavors, the platform default encoding is assumed. See selectBestTextFlavor for a list of text flavors which support the charset parameter.

param
that the DataFlavor to compare with this
return
true if that is equivalent to this DataFlavor; false otherwise
see
#selectBestTextFlavor

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

        if (mimeType == null) {
            if (that.mimeType != null) {
                return false;
            }
        } else {
            if (!mimeType.match(that.mimeType)) {
                return false;
            }

            if ("text".equals(getPrimaryType()) &&
                DataTransferer.doesSubtypeSupportCharset(this) &&
		representationClass != null &&
		!(isRepresentationClassReader() ||
		  String.class.equals(representationClass) ||
                  isRepresentationClassCharBuffer() ||
		  DataTransferer.charArrayClass.equals(representationClass)))
	    {
                String thisCharset =
		    DataTransferer.canonicalName(getParameter("charset"));
                String thatCharset =
		    DataTransferer.canonicalName(that.getParameter("charset"));
                if (thisCharset == null) {
                    if (thatCharset != null) {
                        return false;
                    }
                } else {
                    if (!thisCharset.equals(thatCharset)) {
                        return false;
                    }
                }
            }
        }

        return true;
public booleanequals(java.lang.String s)
Compares only the mimeType against the passed in String and representationClass is not considered in the comparison. If representationClass needs to be compared, then equals(new DataFlavor(s)) may be used.

deprecated
As inconsistent with hashCode() contract, use isMimeTypeEqual(String) instead.
return
true if the String (MimeType) is equal

        if (s == null || mimeType == null)
            return false;
        return isMimeTypeEqual(s);
public final java.lang.ClassgetDefaultRepresentationClass()

        return ioInputStreamClass;
public final java.lang.StringgetDefaultRepresentationClassAsString()

        return getDefaultRepresentationClass().getName();
public java.lang.StringgetHumanPresentableName()
Returns the human presentable name for the data format that this DataFlavor represents. This name would be localized for different countries.

return
the human presentable name for the data format that this DataFlavor represents

        return humanPresentableName;
public java.lang.StringgetMimeType()
Returns the MIME type string for this DataFlavor.

return
the MIME type string for this flavor

        return (mimeType != null) ? mimeType.toString() : null;
public java.lang.StringgetParameter(java.lang.String paramName)
Returns the human presentable name for this DataFlavor if paramName equals "humanPresentableName". Otherwise returns the MIME type value associated with paramName.

param
paramName the parameter name requested
return
the value of the name parameter, or null if there is no associated value

        if (paramName.equals("humanPresentableName")) {
            return humanPresentableName;
        } else {
            return (mimeType != null)
                ? mimeType.getParameter(paramName) : null;
        }
public java.lang.StringgetPrimaryType()
Returns the primary MIME type for this DataFlavor.

return
the primary MIME type of this DataFlavor

        return (mimeType != null) ? mimeType.getPrimaryType() : null;
public java.io.ReadergetReaderForText(java.awt.datatransfer.Transferable transferable)
Gets a Reader for a text flavor, decoded, if necessary, for the expected charset (encoding). The supported representation classes are java.io.Reader, java.lang.String, java.nio.CharBuffer, [C, java.io.InputStream, java.nio.ByteBuffer, and [B.

Because text flavors which do not support the charset parameter are encoded in a non-standard format, this method should not be called for such flavors. However, in order to maintain backward-compatibility, if this method is called for such a flavor, this method will treat the flavor as though it supports the charset parameter and attempt to decode it accordingly. See selectBestTextFlavor for a list of text flavors which do not support the charset parameter.

param
transferable the Transferable whose data will be requested in this flavor
return
a Reader to read the Transferable's data
exception
IllegalArgumentException if the representation class is not one of the seven listed above
exception
IllegalArgumentException if the Transferable has null data
exception
NullPointerException if the Transferable is null
exception
UnsupportedEncodingException if this flavor's representation is java.io.InputStream, java.nio.ByteBuffer, or [B and this flavor's encoding is not supported by this implementation of the Java platform
exception
UnsupportedFlavorException if the Transferable does not support this flavor
exception
IOException if the data cannot be read because of an I/O error
see
#selectBestTextFlavor
since
1.3

	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 java.lang.ClassgetRepresentationClass()
Returns the Class which objects supporting this DataFlavor will return when this DataFlavor is requested.

return
the Class which objects supporting this DataFlavor will return when this DataFlavor is requested

        return representationClass;
public java.lang.StringgetSubType()
Returns the sub MIME type of this DataFlavor.

return
the Sub MIME type of this DataFlavor

        return (mimeType != null) ? mimeType.getSubType() : null;
public static final java.awt.datatransfer.DataFlavorgetTextPlainUnicodeFlavor()
Returns a DataFlavor representing plain text with Unicode encoding, where: 
representationClass = java.io.InputStream
mimeType = "text/plain;
charset=<platform default Unicode encoding>"
Sun's implementation for Microsoft Windows uses the encoding utf-16le. Sun's implementation for Solaris and Linux uses the encoding iso-10646-ucs-2.

return
a DataFlavor representing plain text with Unicode encoding

	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 inthashCode()
Returns hash code for this DataFlavor. For two equal DataFlavors, hash codes are equal. For the String that matches DataFlavor.equals(String), it is not guaranteed that DataFlavor's hash code is equal to the hash code of the String.

return
a hash code for this DataFlavor

        int total = 0;

        if (representationClass != null) {
            total += representationClass.hashCode();
        }

        if (mimeType != null) {
            String primaryType = mimeType.getPrimaryType();
            if (primaryType != null) {
                total += primaryType.hashCode();
            }

            // Do not add subType.hashCode() to the total. equals uses
            // MimeType.match which reports a match if one or both of the
            // subTypes is '*', regardless of the other subType.

            if ("text".equals(primaryType) &&
                DataTransferer.doesSubtypeSupportCharset(this) &&
                representationClass != null &&
                !(isRepresentationClassReader() ||
                  String.class.equals(representationClass) ||
                  isRepresentationClassCharBuffer() ||
                  DataTransferer.charArrayClass.equals
                  (representationClass)))
            {
                String charset =
                    DataTransferer.canonicalName(getParameter("charset"));
                if (charset != null) {
                    total += charset.hashCode();
                }
            }
        }

        return total;
private voidinitialize(java.lang.String mimeType, java.lang.String humanPresentableName, java.lang.ClassLoader classLoader)
Common initialization code called from various constructors.

param
mimeType the MIME Content Type (must have a class= param)
param
humanPresentableName the human Presentable Name or null
param
classLoader the fallback class loader to resolve against
throws
MimeTypeParseException
throws
ClassNotFoundException
throws
NullPointerException if mimeType is null
see
tryToLoadClass

        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 booleanisFlavorJavaFileListType()
Returns true if the DataFlavor specified represents a list of file objects.

return
true if the DataFlavor specified represents a List of File objects

        if (mimeType == null || representationClass == null)
            return false;
        return java.util.List.class.isAssignableFrom(representationClass) &&
               mimeType.match(javaFileListFlavor.mimeType);
public booleanisFlavorRemoteObjectType()
Returns true if the DataFlavor specified represents a remote object.

return
true if the DataFlavor specified represents a Remote Object

        return isRepresentationClassRemote() 
            && isRepresentationClassSerializable() 
            && isMimeTypeEqual(javaRemoteObjectMimeType);
public booleanisFlavorSerializedObjectType()
Returns true if the DataFlavor specified represents a serialized object.

return
true if the DataFlavor specified represents a Serialized Object

        return isRepresentationClassSerializable() && isMimeTypeEqual(javaSerializedObjectMimeType);
public booleanisFlavorTextType()
Returns whether this DataFlavor is a valid text flavor for this implementation of the Java platform. Only flavors equivalent to DataFlavor.stringFlavor and DataFlavors with a primary MIME type of "text" can be valid text flavors.

If this flavor supports the charset parameter, it must be equivalent to DataFlavor.stringFlavor, or its representation must be java.io.Reader, java.lang.String, java.nio.CharBuffer, [C, java.io.InputStream, java.nio.ByteBuffer, or [B. If the representation is java.io.InputStream, java.nio.ByteBuffer, or [B, then this flavor's charset parameter must be supported by this implementation of the Java platform. If a charset is not specified, then the platform default charset, which is always supported, is assumed.

If this flavor does not support the charset parameter, its representation must be java.io.InputStream, java.nio.ByteBuffer, or [B.

See selectBestTextFlavor for a list of text flavors which support the charset parameter.

return
true if this DataFlavor is a valid text flavor as described above; false otherwise
see
#selectBestTextFlavor
since
1.4

 
        return (DataTransferer.isFlavorCharsetTextType(this) ||
                DataTransferer.isFlavorNoncharsetTextType(this));
public booleanisMimeTypeEqual(java.lang.String mimeType)
Returns whether the string representation of the MIME type passed in is equivalent to the MIME type of this DataFlavor. Parameters are not included in the comparison.

param
mimeType the string representation of the MIME type
return
true if the string representation of the MIME type passed in is equivalent to the MIME type of this DataFlavor; false otherwise
throws
NullPointerException if mimeType is null

	// JCK Test DataFlavor0117: if 'mimeType' is null, throw NPE
	if (mimeType == null) {
	    throw new NullPointerException("mimeType");
	}
        if (this.mimeType == null) {
            return false;
        }
        try {
            return this.mimeType.match(new MimeType(mimeType));
        } catch (MimeTypeParseException mtpe) {
            return false; 
        }
public final booleanisMimeTypeEqual(java.awt.datatransfer.DataFlavor dataFlavor)
Compares the mimeType of two DataFlavor objects. No parameters are considered.

param
dataFlavor the DataFlavor to be compared
return
true if the MimeTypes are equal, otherwise false

        return isMimeTypeEqual(dataFlavor.mimeType);
private booleanisMimeTypeEqual(java.awt.datatransfer.MimeType mtype)
Compares the mimeType of two DataFlavor objects. No parameters are considered.

return
true if the MimeTypes are equal, otherwise false

        if (this.mimeType == null) {
            return (mtype == null);
        }
        return mimeType.match(mtype);
public booleanisMimeTypeSerializedObject()
Does the DataFlavor represent a serialized object?

        return isMimeTypeEqual(javaSerializedObjectMimeType);
public booleanisRepresentationClassByteBuffer()
Returns whether the representation class for this DataFlavor is java.nio.ByteBuffer or a subclass thereof.

since
1.4

        return java.nio.ByteBuffer.class.isAssignableFrom(representationClass);
public booleanisRepresentationClassCharBuffer()
Returns whether the representation class for this DataFlavor is java.nio.CharBuffer or a subclass thereof.

since
1.4

        return java.nio.CharBuffer.class.isAssignableFrom(representationClass);
public booleanisRepresentationClassInputStream()
Does the DataFlavor represent a java.io.InputStream?

        return ioInputStreamClass.isAssignableFrom(representationClass);
public booleanisRepresentationClassReader()
Returns whether the representation class for this DataFlavor is java.io.Reader or a subclass thereof.

since
1.4

	return java.io.Reader.class.isAssignableFrom(representationClass);
public booleanisRepresentationClassRemote()
Returns true if the representation class is Remote.

return
true if the representation class is Remote

        return java.rmi.Remote.class.isAssignableFrom(representationClass);
public booleanisRepresentationClassSerializable()
Returns true if the representation class can be serialized.

return
true if the representation class can be serialized

        return java.io.Serializable.class.isAssignableFrom(representationClass);
public booleanmatch(java.awt.datatransfer.DataFlavor that)
Tests a DataFlavor to this DataFlavor for equality. Two DataFlavors are considered equal if and only if their MIME primary type and subtype and representation class are equal. Additionally, if the primary type is "text", the subtype denotes a text flavor which supports the charset parameter, and the representation class is not java.io.Reader, java.lang.String, java.nio.CharBuffer, or [C, the charset parameter must also be equal. If a charset is not explicitly specified for one or both DataFlavors, the platform default encoding is assumed. See selectBestTextFlavor for a list of text flavors which support the charset parameter.

param
that the DataFlavor to compare with this
return
true if that is equivalent to this DataFlavor; false otherwise
see
#selectBestTextFlavor

	return equals(that);
protected java.lang.StringnormalizeMimeType(java.lang.String mimeType)
Called for each MIME type string to give DataFlavor subtypes the opportunity to change how the normalization of MIME types is accomplished. One possible use would be to add default parameter/value pairs in cases where none are present in the MIME type string passed in. This method is never invoked by this implementation from 1.1 onwards.

deprecated

        return mimeType;
protected java.lang.StringnormalizeMimeTypeParameter(java.lang.String parameterName, java.lang.String parameterValue)
Called on DataFlavor for every MIME Type parameter to allow DataFlavor subclasses to handle special parameters like the text/plain charset parameters, whose values are case insensitive. (MIME type parameter values are supposed to be case sensitive.

This method is called for each parameter name/value pair and should return the normalized representation of the parameterValue. This method is never invoked by this implementation from 1.1 onwards.

deprecated

        return parameterValue;
private java.lang.StringparamString()

        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 synchronized voidreadExternal(java.io.ObjectInput is)
Restores this DataFlavor from a Serialized state.

       String rcn = null;
        mimeType = (MimeType)is.readObject();

        if (mimeType != null) {
            humanPresentableName =
                mimeType.getParameter("humanPresentableName");
            mimeType.removeParameter("humanPresentableName");
            rcn = mimeType.getParameter("class");
            if (rcn == null) {
                throw new IOException("no class parameter specified in: " +
                                      mimeType);
            }
        }

        try {
            representationClass = (Class)is.readObject();
        } catch (OptionalDataException ode) {
            if (!ode.eof || ode.length != 0) {
                throw ode;
            }
            // Ensure backward compatibility.
            // Old versions didn't write the representation class to the stream.
            if (rcn != null) {
                representationClass =
                    DataFlavor.tryToLoadClass(rcn, getClass().getClassLoader());
            }
        }
public static final java.awt.datatransfer.DataFlavorselectBestTextFlavor(java.awt.datatransfer.DataFlavor[] availableFlavors)
Selects the best text DataFlavor from an array of DataFlavors. Only DataFlavor.stringFlavor, and equivalent flavors, and flavors that have a primary MIME type of "text", are considered for selection.

Flavors are first sorted by their MIME types in the following order:

  • "text/sgml"
  • "text/xml"
  • "text/html"
  • "text/rtf"
  • "text/enriched"
  • "text/richtext"
  • "text/uri-list"
  • "text/tab-separated-values"
  • "text/t140"
  • "text/rfc822-headers"
  • "text/parityfec"
  • "text/directory"
  • "text/css"
  • "text/calendar"
  • "application/x-java-serialized-object"
  • "text/plain"
  • "text/<other>"

For example, "text/sgml" will be selected over "text/html", and DataFlavor.stringFlavor will be chosen over DataFlavor.plainTextFlavor.

If two or more flavors share the best MIME type in the array, then that MIME type will be checked to see if it supports the charset parameter.

The following MIME types support, or are treated as though they support, the charset parameter:

  • "text/sgml"
  • "text/xml"
  • "text/html"
  • "text/enriched"
  • "text/richtext"
  • "text/uri-list"
  • "text/directory"
  • "text/css"
  • "text/calendar"
  • "application/x-java-serialized-object"
  • "text/plain"
The following MIME types do not support, or are treated as though they do not support, the charset parameter:
  • "text/rtf"
  • "text/tab-separated-values"
  • "text/t140"
  • "text/rfc822-headers"
  • "text/parityfec"
For "text/<other>" MIME types, the first time the JRE needs to determine whether the MIME type supports the charset parameter, it will check whether the parameter is explicitly listed in an arbitrarily chosen DataFlavor which uses that MIME type. If so, the JRE will assume from that point on that the MIME type supports the charset parameter and will not check again. If the parameter is not explicitly listed, the JRE will assume from that point on that the MIME type does not support the charset parameter and will not check again. Because this check is performed on an arbitrarily chosen DataFlavor, developers must ensure that all DataFlavors with a "text/<other>" MIME type specify the charset parameter if it is supported by that MIME type. Developers should never rely on the JRE to substitute the platform's default charset for a "text/<other>" DataFlavor. Failure to adhere to this restriction will lead to undefined behavior.

If the best MIME type in the array does not support the charset parameter, the flavors which share that MIME type will then be sorted by their representation classes in the following order: java.io.InputStream, java.nio.ByteBuffer, [B, <all others>.

If two or more flavors share the best representation class, or if no flavor has one of the three specified representations, then one of those flavors will be chosen non-deterministically.

If the best MIME type in the array does support the charset parameter, the flavors which share that MIME type will then be sorted by their representation classes in the following order: java.io.Reader, java.lang.String, java.nio.CharBuffer, [C, <all others>.

If two or more flavors share the best representation class, and that representation is one of the four explicitly listed, then one of those flavors will be chosen non-deterministically. If, however, no flavor has one of the four specified representations, the flavors will then be sorted by their charsets. Unicode charsets, such as "UTF-16", "UTF-8", "UTF-16BE", "UTF-16LE", and their aliases, are considered best. After them, the platform default charset and its aliases are selected. "US-ASCII" and its aliases are worst. All other charsets are chosen in alphabetical order, but only charsets supported by this implementation of the Java platform will be considered.

If two or more flavors share the best charset, the flavors will then again be sorted by their representation classes in the following order: java.io.InputStream, java.nio.ByteBuffer, [B, <all others>.

If two or more flavors share the best representation class, or if no flavor has one of the three specified representations, then one of those flavors will be chosen non-deterministically.

param
availableFlavors an array of available DataFlavors
return
the best (highest fidelity) flavor according to the rules specified above, or null, if availableFlavors is null, has zero length, or contains no text flavors
since
1.3

        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;
public voidsetHumanPresentableName(java.lang.String humanPresentableName)
Sets the human presentable name for the data format that this DataFlavor represents. This name would be localized for different countries.

param
humanPresentableName the new human presentable name

        this.humanPresentableName = humanPresentableName;
public java.lang.StringtoString()
String representation of this DataFlavor and its parameters. The resulting String contains the name of the DataFlavor class, this flavor's MIME type, and its representation class. If this flavor has a primary MIME type of "text", supports the charset parameter, and has an encoded representation, the flavor's charset is also included. See selectBestTextFlavor for a list of text flavors which support the charset parameter.

return
string representation of this DataFlavor
see
#selectBestTextFlavor

        String string = getClass().getName();
        string += "["+paramString()+"]";
        return string;
protected static final java.lang.ClasstryToLoadClass(java.lang.String className, java.lang.ClassLoader fallback)
Tries to load a class from: the bootstrap loader, the system loader, the context loader (if one is present) and finally the loader specified.

param
className the name of the class to be loaded
param
fallback the fallback loader
return
the class loaded
exception
ClassNotFoundException if class is not found


                                                           
         
						     
         
    
	ClassLoader systemClassLoader = (ClassLoader)
	    java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction() {
		    public Object run() {
			ClassLoader cl = Thread.currentThread().
			    getContextClassLoader();
			return (cl != null)
			    ? cl
			    : ClassLoader.getSystemClassLoader();
		    }
		    });
	
	try {
	    return Class.forName(className, true, systemClassLoader);
	} catch (ClassNotFoundException e2) {
	    if (fallback != null) {
		return Class.forName(className, true, fallback);
	    } else {
		throw new ClassNotFoundException(className);
	    }
	}
public synchronized voidwriteExternal(java.io.ObjectOutput os)
Serializes this DataFlavor.

       if (mimeType != null) {
           mimeType.setParameter("humanPresentableName", humanPresentableName);
           os.writeObject(mimeType);
           mimeType.removeParameter("humanPresentableName");
       } else {
           os.writeObject(null);
       }
       
       os.writeObject(representationClass);