Java DataFlavor.getRepresentationClass方法代码示例

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
@Override
public void dragEnter(DropTargetDragEvent dtde) {
    accept = null;
    value = null;
    for (DataFlavor dataFlavor : dtde.getCurrentDataFlavors()) {
        Object obj = null;
        try {
            obj = dtde.getTransferable().getTransferData(dataFlavor);
        } catch (Exception ex) {
            continue;
        }
        if (dataFlavor.isFlavorJavaFileListType()) {
            accept = dataFlavor;
            value = obj;
            break;
        }
        if ("text".equals(dataFlavor.getPrimaryType()) && "uri-list".equals(dataFlavor.getSubType()) && dataFlavor.getRepresentationClass() == String.class) {
            accept = dataFlavor;
            value = (String) obj;
            break;
        }
    }
    if (accept != null) {
        dtde.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE);
    }
}
 

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
/**
 * Returns whether this flavor is a text type which supports the
 * 'charset' parameter.
 */
public static boolean isFlavorCharsetTextType(DataFlavor flavor) {
    // Although stringFlavor doesn't actually support the charset
    // parameter (because its primary MIME type is not "text"), it should
    // be treated as though it does. stringFlavor is semantically
    // equivalent to "text/plain" data.
    if (DataFlavor.stringFlavor.equals(flavor)) {
        return true;
    }

    if (!"text".equals(flavor.getPrimaryType()) ||
        !doesSubtypeSupportCharset(flavor))
    {
        return false;
    }

    Class rep_class = flavor.getRepresentationClass();

    if (flavor.isRepresentationClassReader() ||
        String.class.equals(rep_class) ||
        flavor.isRepresentationClassCharBuffer() ||
        char[].class.equals(rep_class))
    {
        return true;
    }

    if (!(flavor.isRepresentationClassInputStream() ||
          flavor.isRepresentationClassByteBuffer() ||
          byte[].class.equals(rep_class))) {
        return false;
    }

    String charset = flavor.getParameter("charset");

    return (charset != null)
        ? DataTransferer.isEncodingSupported(charset)
        : true; // null equals default encoding which is always supported
}
 

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
/**
 * We support representations which are exactly of the specified Class,
 * and also arbitrary Objects which have a constructor which takes an
 * instance of the Class as its sole parameter.
 */
private Object constructFlavoredObject(Object arg, DataFlavor flavor,
                                       Class<?> clazz)
    throws IOException
{
    final Class<?> dfrc = flavor.getRepresentationClass();

    if (clazz.equals(dfrc)) {
        return arg; // simple case
    } else {
        Constructor<?>[] constructors;

        try {
            constructors = AccessController.doPrivileged(
                    (PrivilegedAction<Constructor<?>[]>) dfrc::getConstructors);
        } catch (SecurityException se) {
            throw new IOException(se.getMessage());
        }

        Constructor<?> constructor = Stream.of(constructors)
                .filter(c -> Modifier.isPublic(c.getModifiers()))
                .filter(c -> {
                    Class<?>[] ptypes = c.getParameterTypes();
                    return ptypes != null
                            && ptypes.length == 1
                            && clazz.equals(ptypes[0]);
                })
                .findFirst()
                .orElseThrow(() ->
                        new IOException("can't find <init>(L"+ clazz + ";)V for class: " + dfrc.getName()));

        try {
            return constructor.newInstance(arg);
        } catch (Exception e) {
            throw new IOException(e.getMessage());
        }
    }
}
 

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
/**
 * Returns whether this flavor is a text type which supports the 'charset'
 * parameter.
 */
public static boolean isFlavorCharsetTextType(DataFlavor flavor) {
    // Although stringFlavor doesn't actually support the charset
    // parameter (because its primary MIME type is not "text"), it should
    // be treated as though it does. stringFlavor is semantically
    // equivalent to "text/plain" data.
    if (DataFlavor.stringFlavor.equals(flavor)) {
        return true;
    }

    if (!"text".equals(flavor.getPrimaryType()) ||
            !doesSubtypeSupportCharset(flavor))
    {
        return false;
    }

    Class<?> rep_class = flavor.getRepresentationClass();

    if (flavor.isRepresentationClassReader() ||
            String.class.equals(rep_class) ||
            flavor.isRepresentationClassCharBuffer() ||
            char[].class.equals(rep_class))
    {
        return true;
    }

    if (!(flavor.isRepresentationClassInputStream() ||
            flavor.isRepresentationClassByteBuffer() ||
            byte[].class.equals(rep_class))) {
        return false;
    }

    String charset = flavor.getParameter("charset");

    // null equals default encoding which is always supported
    return (charset == null) || isEncodingSupported(charset);
}
 

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
/**
 * We support representations which are exactly of the specified Class,
 * and also arbitrary Objects which have a constructor which takes an
 * instance of the Class as its sole parameter.
 */
private Object constructFlavoredObject(Object arg, DataFlavor flavor,
                                       Class clazz)
    throws IOException
{
    final Class dfrc = flavor.getRepresentationClass();

    if (clazz.equals(dfrc)) {
        return arg; // simple case
    } else {
        Constructor[] constructors = null;

        try {
            constructors = (Constructor[])
                AccessController.doPrivileged(new PrivilegedAction() {
                        public Object run() {
                            return dfrc.getConstructors();
                        }
                    });
        } catch (SecurityException se) {
            throw new IOException(se.getMessage());
        }

        Constructor constructor = null;

        for (int j = 0; j < constructors.length; j++) {
            if (!Modifier.isPublic(constructors[j].getModifiers())) {
                continue;
            }

            Class[] ptypes = constructors[j].getParameterTypes();

            if (ptypes != null && ptypes.length == 1 &&
                clazz.equals(ptypes[0])) {
                constructor = constructors[j];
                break;
            }
        }

        if (constructor == null) {
            throw new IOException("can't find <init>(L"+ clazz +
                                  ";)V for class: " + dfrc.getName());
        }

        try {
            return constructor.newInstance(new Object[] { arg } );
        } catch (Exception e) {
            throw new IOException(e.getMessage());
        }
    }
}
 

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
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;
}
 

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
@Override
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 && DataFlavorUtil.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 (String mime : mimeTypes) {
                Iterator<ImageWriter> writers = ImageIO.getImageWritersByMIMEType(mime);
                while (writers.hasNext()) {
                    ImageWriter imageWriter = writers.next();
                    ImageWriterSpi writerSpi = imageWriter.getOriginatingProvider();

                    if (writerSpi != null &&
                            writerSpi.canEncodeImage(getDefaultImageTypeSpecifier())) {
                        natives.add(mime);
                        break;
                    }
                }
            }
        }
    } else if (DataFlavorUtil.isFlavorCharsetTextType(df)) {
        // stringFlavor is semantically equivalent to the standard
        // "text/plain" MIME type.
        if (DataFlavor.stringFlavor.equals(df)) {
            baseType = "text/plain";
        }

        for (String encoding : DataFlavorUtil.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;
}
 

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
/**
 * Compares the DataFlavor passed in with this DataFlavor; calls
 * the <code>isMimeTypeEqual</code> method.
 *
 * @param dataFlavor        the DataFlavor to compare with
 * @return                  true if the MIME type and representation class
 *                          are the same
 */
public boolean equals(DataFlavor dataFlavor) {
    return (isMimeTypeEqual(dataFlavor) &&
            dataFlavor.getRepresentationClass() == representationClass);
}
 

import java.awt.datatransfer.DataFlavor; //导入方法依赖的package包/类
/**
 * Compares the DataFlavor passed in with this DataFlavor; calls
 * the {@code isMimeTypeEqual} method.
 *
 * @param dataFlavor        the DataFlavor to compare with
 * @return                  true if the MIME type and representation class
 *                          are the same
 */
public boolean equals(DataFlavor dataFlavor) {
    return (isMimeTypeEqual(dataFlavor) &&
            dataFlavor.getRepresentationClass() == representationClass);
}