下面列出了java.awt.datatransfer.DataFlavor#getPrimaryType ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
protected byte[] imageToPlatformBytes(Image image, long format)
throws IOException {
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return imageToStandardBytes(image, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation to " + nativeFormat +
" is not supported.");
}
}
protected byte[] imageToPlatformBytes(Image image, long format)
throws IOException {
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return imageToStandardBytes(image, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation to " + nativeFormat +
" is not supported.");
}
}
/**
* Translates either a byte array or an input stream which contain
* platform-specific image data in the given format into an Image.
*/
protected Image platformImageBytesToImage(
byte[] bytes, long format) throws IOException
{
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return standardImageBytesToImage(bytes, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation from " + nativeFormat +
" is not supported.");
}
}
protected byte[] imageToPlatformBytes(Image image, long format)
throws IOException {
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return imageToStandardBytes(image, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation to " + nativeFormat +
" is not supported.");
}
}
protected byte[] imageToPlatformBytes(Image image, long format)
throws IOException {
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return imageToStandardBytes(image, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation to " + nativeFormat +
" is not supported.");
}
}
/**
* Translates either a byte array or an input stream which contain
* platform-specific image data in the given format into an Image.
*/
protected Image platformImageBytesToImage(
byte[] bytes, long format) throws IOException
{
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return standardImageBytesToImage(bytes, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation from " + nativeFormat +
" is not supported.");
}
}
protected byte[] imageToPlatformBytes(Image image, long format)
throws IOException {
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return imageToStandardBytes(image, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation to " + nativeFormat +
" is not supported.");
}
}
/**
* Translates either a byte array or an input stream which contain
* platform-specific image data in the given format into an Image.
*/
protected Image platformImageBytesToImage(
byte[] bytes, long format) throws IOException
{
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return standardImageBytesToImage(bytes, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation from " + nativeFormat +
" is not supported.");
}
}
/**
* Translates either a byte array or an input stream which contain
* platform-specific image data in the given format into an Image.
*/
protected Image platformImageBytesToImage(
byte[] bytes, long format) throws IOException
{
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return standardImageBytesToImage(bytes, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation from " + nativeFormat +
" is not supported.");
}
}
/**
* Translates either a byte array or an input stream which contain
* platform-specific image data in the given format into an Image.
*/
protected Image platformImageBytesToImage(
byte[] bytes, long format) throws IOException
{
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return standardImageBytesToImage(bytes, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation from " + nativeFormat +
" is not supported.");
}
}
/**
* Translates either a byte array or an input stream which contain
* platform-specific image data in the given format into an Image.
*/
protected Image platformImageBytesToImage(
byte[] bytes, long format) throws IOException
{
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return standardImageBytesToImage(bytes, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation from " + nativeFormat +
" is not supported.");
}
}
protected byte[] imageToPlatformBytes(Image image, long format)
throws IOException {
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return imageToStandardBytes(image, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation to " + nativeFormat +
" is not supported.");
}
}
protected byte[] imageToPlatformBytes(Image image, long format)
throws IOException {
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return imageToStandardBytes(image, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation to " + nativeFormat +
" is not supported.");
}
}
/**
* Translates either a byte array or an input stream which contain
* platform-specific image data in the given format into an Image.
*/
@Override
protected Image platformImageBytesToImage(
byte[] bytes, long format) throws IOException
{
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return standardImageBytesToImage(bytes, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation from " + nativeFormat +
" is not supported.");
}
}
/**
* Translates either a byte array or an input stream which contain
* platform-specific image data in the given format into an Image.
*/
protected Image platformImageBytesToImage(
byte[] bytes, long format) throws IOException
{
String mimeType = null;
if (format == PNG_ATOM.getAtom()) {
mimeType = "image/png";
} else if (format == JFIF_ATOM.getAtom()) {
mimeType = "image/jpeg";
} else {
// Check if an image MIME format.
try {
String nat = getNativeForFormat(format);
DataFlavor df = new DataFlavor(nat);
String primaryType = df.getPrimaryType();
if ("image".equals(primaryType)) {
mimeType = df.getPrimaryType() + "/" + df.getSubType();
}
} catch (Exception e) {
// Not an image MIME format.
}
}
if (mimeType != null) {
return standardImageBytesToImage(bytes, mimeType);
} else {
String nativeFormat = getNativeForFormat(format);
throw new IOException("Translation from " + nativeFormat +
" is not supported.");
}
}
public LinkedHashSet<String> getPlatformMappingsForFlavor(DataFlavor df) {
LinkedHashSet<String> natives = new LinkedHashSet<>(1);
if (df == null) {
return natives;
}
String charset = df.getParameter("charset");
String baseType = df.getPrimaryType() + "/" + df.getSubType();
String mimeType = baseType;
if (charset != null && DataTransferer.isFlavorCharsetTextType(df)) {
mimeType += ";charset=" + charset;
}
// Add a mapping to the MIME native whenever the representation class
// doesn't require translation.
if (df.getRepresentationClass() != null &&
(df.isRepresentationClassInputStream() ||
df.isRepresentationClassByteBuffer() ||
byte[].class.equals(df.getRepresentationClass()))) {
natives.add(mimeType);
}
if (DataFlavor.imageFlavor.equals(df)) {
String[] mimeTypes = ImageIO.getWriterMIMETypes();
if (mimeTypes != null) {
for (int i = 0; i < mimeTypes.length; i++) {
Iterator writers =
ImageIO.getImageWritersByMIMEType(mimeTypes[i]);
while (writers.hasNext()) {
ImageWriter imageWriter = (ImageWriter)writers.next();
ImageWriterSpi writerSpi =
imageWriter.getOriginatingProvider();
if (writerSpi != null &&
writerSpi.canEncodeImage(getDefaultImageTypeSpecifier())) {
natives.add(mimeTypes[i]);
break;
}
}
}
}
} else if (DataTransferer.isFlavorCharsetTextType(df)) {
// stringFlavor is semantically equivalent to the standard
// "text/plain" MIME type.
if (DataFlavor.stringFlavor.equals(df)) {
baseType = "text/plain";
}
for (String encoding : DataTransferer.standardEncodings()) {
if (!encoding.equals(charset)) {
natives.add(baseType + ";charset=" + encoding);
}
}
// Add a MIME format without specified charset.
if (!natives.contains(baseType)) {
natives.add(baseType);
}
}
return natives;
}
public LinkedHashSet<String> getPlatformMappingsForFlavor(DataFlavor df) {
LinkedHashSet<String> natives = new LinkedHashSet<>(1);
if (df == null) {
return natives;
}
String charset = df.getParameter("charset");
String baseType = df.getPrimaryType() + "/" + df.getSubType();
String mimeType = baseType;
if (charset != null && DataTransferer.isFlavorCharsetTextType(df)) {
mimeType += ";charset=" + charset;
}
// Add a mapping to the MIME native whenever the representation class
// doesn't require translation.
if (df.getRepresentationClass() != null &&
(df.isRepresentationClassInputStream() ||
df.isRepresentationClassByteBuffer() ||
byte[].class.equals(df.getRepresentationClass()))) {
natives.add(mimeType);
}
if (DataFlavor.imageFlavor.equals(df)) {
String[] mimeTypes = ImageIO.getWriterMIMETypes();
if (mimeTypes != null) {
for (int i = 0; i < mimeTypes.length; i++) {
Iterator writers =
ImageIO.getImageWritersByMIMEType(mimeTypes[i]);
while (writers.hasNext()) {
ImageWriter imageWriter = (ImageWriter)writers.next();
ImageWriterSpi writerSpi =
imageWriter.getOriginatingProvider();
if (writerSpi != null &&
writerSpi.canEncodeImage(getDefaultImageTypeSpecifier())) {
natives.add(mimeTypes[i]);
break;
}
}
}
}
} else if (DataTransferer.isFlavorCharsetTextType(df)) {
// stringFlavor is semantically equivalent to the standard
// "text/plain" MIME type.
if (DataFlavor.stringFlavor.equals(df)) {
baseType = "text/plain";
}
for (String encoding : DataTransferer.standardEncodings()) {
if (!encoding.equals(charset)) {
natives.add(baseType + ";charset=" + encoding);
}
}
// Add a MIME format without specified charset.
if (!natives.contains(baseType)) {
natives.add(baseType);
}
}
return natives;
}
public LinkedHashSet<String> getPlatformMappingsForFlavor(DataFlavor df) {
LinkedHashSet<String> natives = new LinkedHashSet<>(1);
if (df == null) {
return natives;
}
String charset = df.getParameter("charset");
String baseType = df.getPrimaryType() + "/" + df.getSubType();
String mimeType = baseType;
if (charset != null && DataTransferer.isFlavorCharsetTextType(df)) {
mimeType += ";charset=" + charset;
}
// Add a mapping to the MIME native whenever the representation class
// doesn't require translation.
if (df.getRepresentationClass() != null &&
(df.isRepresentationClassInputStream() ||
df.isRepresentationClassByteBuffer() ||
byte[].class.equals(df.getRepresentationClass()))) {
natives.add(mimeType);
}
if (DataFlavor.imageFlavor.equals(df)) {
String[] mimeTypes = ImageIO.getWriterMIMETypes();
if (mimeTypes != null) {
for (int i = 0; i < mimeTypes.length; i++) {
Iterator writers =
ImageIO.getImageWritersByMIMEType(mimeTypes[i]);
while (writers.hasNext()) {
ImageWriter imageWriter = (ImageWriter)writers.next();
ImageWriterSpi writerSpi =
imageWriter.getOriginatingProvider();
if (writerSpi != null &&
writerSpi.canEncodeImage(getDefaultImageTypeSpecifier())) {
natives.add(mimeTypes[i]);
break;
}
}
}
}
} else if (DataTransferer.isFlavorCharsetTextType(df)) {
// stringFlavor is semantically equivalent to the standard
// "text/plain" MIME type.
if (DataFlavor.stringFlavor.equals(df)) {
baseType = "text/plain";
}
for (String encoding : DataTransferer.standardEncodings()) {
if (!encoding.equals(charset)) {
natives.add(baseType + ";charset=" + encoding);
}
}
// Add a MIME format without specified charset.
if (!natives.contains(baseType)) {
natives.add(baseType);
}
}
return natives;
}
public LinkedHashSet<String> getPlatformMappingsForFlavor(DataFlavor df) {
LinkedHashSet<String> natives = new LinkedHashSet<>(1);
if (df == null) {
return natives;
}
String charset = df.getParameter("charset");
String baseType = df.getPrimaryType() + "/" + df.getSubType();
String mimeType = baseType;
if (charset != null && DataTransferer.isFlavorCharsetTextType(df)) {
mimeType += ";charset=" + charset;
}
// Add a mapping to the MIME native whenever the representation class
// doesn't require translation.
if (df.getRepresentationClass() != null &&
(df.isRepresentationClassInputStream() ||
df.isRepresentationClassByteBuffer() ||
byte[].class.equals(df.getRepresentationClass()))) {
natives.add(mimeType);
}
if (DataFlavor.imageFlavor.equals(df)) {
String[] mimeTypes = ImageIO.getWriterMIMETypes();
if (mimeTypes != null) {
for (int i = 0; i < mimeTypes.length; i++) {
Iterator writers =
ImageIO.getImageWritersByMIMEType(mimeTypes[i]);
while (writers.hasNext()) {
ImageWriter imageWriter = (ImageWriter)writers.next();
ImageWriterSpi writerSpi =
imageWriter.getOriginatingProvider();
if (writerSpi != null &&
writerSpi.canEncodeImage(getDefaultImageTypeSpecifier())) {
natives.add(mimeTypes[i]);
break;
}
}
}
}
} else if (DataTransferer.isFlavorCharsetTextType(df)) {
// stringFlavor is semantically equivalent to the standard
// "text/plain" MIME type.
if (DataFlavor.stringFlavor.equals(df)) {
baseType = "text/plain";
}
for (String encoding : DataTransferer.standardEncodings()) {
if (!encoding.equals(charset)) {
natives.add(baseType + ";charset=" + encoding);
}
}
// Add a MIME format without specified charset.
if (!natives.contains(baseType)) {
natives.add(baseType);
}
}
return natives;
}
public int compare(DataFlavor flavor1, DataFlavor flavor2) {
if (flavor1.equals(flavor2)) {
return 0;
}
int comp;
String primaryType1 = flavor1.getPrimaryType();
String subType1 = flavor1.getSubType();
String mimeType1 = primaryType1 + "/" + subType1;
Class<?> class1 = flavor1.getRepresentationClass();
String primaryType2 = flavor2.getPrimaryType();
String subType2 = flavor2.getSubType();
String mimeType2 = primaryType2 + "/" + subType2;
Class<?> class2 = flavor2.getRepresentationClass();
if (flavor1.isFlavorTextType() && flavor2.isFlavorTextType()) {
// First, compare MIME types
comp = compareIndices(textTypes, mimeType1, mimeType2, UNKNOWN_OBJECT_LOSES);
if (comp != 0) {
return comp;
}
// Only need to test one flavor because they both have the
// same MIME type. Also don't need to worry about accidentally
// passing stringFlavor because either
// 1. Both flavors are stringFlavor, in which case the
// equality test at the top of the function succeeded.
// 2. Only one flavor is stringFlavor, in which case the MIME
// type comparison returned a non-zero value.
if (doesSubtypeSupportCharset(flavor1)) {
// Next, prefer the decoded text representations of Reader,
// String, CharBuffer, and [C, in that order.
comp = compareIndices(decodedTextRepresentations, class1,
class2, UNKNOWN_OBJECT_LOSES);
if (comp != 0) {
return comp;
}
// Next, compare charsets
comp = CharsetComparator.INSTANCE.compare(getTextCharset(flavor1),
getTextCharset(flavor2));
if (comp != 0) {
return comp;
}
}
// Finally, prefer the encoded text representations of
// InputStream, ByteBuffer, and [B, in that order.
comp = compareIndices(encodedTextRepresentations, class1,
class2, UNKNOWN_OBJECT_LOSES);
if (comp != 0) {
return comp;
}
} else {
// First, prefer text types
if (flavor1.isFlavorTextType()) {
return 1;
}
if (flavor2.isFlavorTextType()) {
return -1;
}
// Next, prefer application types.
comp = compareIndices(primaryTypes, primaryType1, primaryType2,
UNKNOWN_OBJECT_LOSES);
if (comp != 0) {
return comp;
}
// Next, look for application/x-java-* types. Prefer unknown
// MIME types because if the user provides his own data flavor,
// it will likely be the most descriptive one.
comp = compareIndices(exactTypes, mimeType1, mimeType2,
UNKNOWN_OBJECT_WINS);
if (comp != 0) {
return comp;
}
// Finally, prefer the representation classes of Remote,
// Serializable, and InputStream, in that order.
comp = compareIndices(nonTextRepresentations, class1, class2,
UNKNOWN_OBJECT_LOSES);
if (comp != 0) {
return comp;
}
}
// The flavours are not equal but still not distinguishable.
// Compare String representations in alphabetical order
return flavor1.getMimeType().compareTo(flavor2.getMimeType());
}