| /* |
| * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package java.awt.datatransfer; |
| |
| import java.io.BufferedReader; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.lang.ref.SoftReference; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| |
| import sun.datatransfer.DataFlavorUtil; |
| import sun.datatransfer.DesktopDatatransferService; |
| |
| /** |
| * The SystemFlavorMap is a configurable map between "natives" (Strings), which |
| * correspond to platform-specific data formats, and "flavors" (DataFlavors), |
| * which correspond to platform-independent MIME types. This mapping is used by |
| * the data transfer subsystem to transfer data between Java and native |
| * applications, and between Java applications in separate VMs. |
| * |
| * @since 1.2 |
| */ |
| public final class SystemFlavorMap implements FlavorMap, FlavorTable { |
| |
| /** |
| * Constant prefix used to tag Java types converted to native platform type. |
| */ |
| private static String JavaMIME = "JAVA_DATAFLAVOR:"; |
| |
| private static final Object FLAVOR_MAP_KEY = new Object(); |
| |
| /** |
| * The list of valid, decoded text flavor representation classes, in order |
| * from best to worst. |
| */ |
| private static final String[] UNICODE_TEXT_CLASSES = { |
| "java.io.Reader", "java.lang.String", "java.nio.CharBuffer", "\"[C\"" |
| }; |
| |
| /** |
| * The list of valid, encoded text flavor representation classes, in order |
| * from best to worst. |
| */ |
| private static final String[] ENCODED_TEXT_CLASSES = { |
| "java.io.InputStream", "java.nio.ByteBuffer", "\"[B\"" |
| }; |
| |
| /** |
| * A String representing text/plain MIME type. |
| */ |
| private static final String TEXT_PLAIN_BASE_TYPE = "text/plain"; |
| |
| /** |
| * A String representing text/html MIME type. |
| */ |
| private static final String HTML_TEXT_BASE_TYPE = "text/html"; |
| |
| /** |
| * Maps native Strings to Lists of DataFlavors (or base type Strings for |
| * text DataFlavors). |
| * <p> |
| * Do not use the field directly, use {@link #getNativeToFlavor} instead. |
| */ |
| private final Map<String, LinkedHashSet<DataFlavor>> nativeToFlavor = new HashMap<>(); |
| |
| /** |
| * Accessor to nativeToFlavor map. Since we use lazy initialization we must |
| * use this accessor instead of direct access to the field which may not be |
| * initialized yet. This method will initialize the field if needed. |
| * |
| * @return nativeToFlavor |
| */ |
| private Map<String, LinkedHashSet<DataFlavor>> getNativeToFlavor() { |
| if (!isMapInitialized) { |
| initSystemFlavorMap(); |
| } |
| return nativeToFlavor; |
| } |
| |
| /** |
| * Maps DataFlavors (or base type Strings for text DataFlavors) to Lists of |
| * native Strings. |
| * <p> |
| * Do not use the field directly, use {@link #getFlavorToNative} instead. |
| */ |
| private final Map<DataFlavor, LinkedHashSet<String>> flavorToNative = new HashMap<>(); |
| |
| /** |
| * Accessor to flavorToNative map. Since we use lazy initialization we must |
| * use this accessor instead of direct access to the field which may not be |
| * initialized yet. This method will initialize the field if needed. |
| * |
| * @return flavorToNative |
| */ |
| private synchronized Map<DataFlavor, LinkedHashSet<String>> getFlavorToNative() { |
| if (!isMapInitialized) { |
| initSystemFlavorMap(); |
| } |
| return flavorToNative; |
| } |
| |
| /** |
| * Maps a text DataFlavor primary mime-type to the native. Used only to |
| * store standard mappings registered in the {@code flavormap.properties}. |
| * <p> |
| * Do not use this field directly, use {@link #getTextTypeToNative} instead. |
| */ |
| private Map<String, LinkedHashSet<String>> textTypeToNative = new HashMap<>(); |
| |
| /** |
| * Shows if the object has been initialized. |
| */ |
| private boolean isMapInitialized = false; |
| |
| /** |
| * An accessor to textTypeToNative map. Since we use lazy initialization we |
| * must use this accessor instead of direct access to the field which may |
| * not be initialized yet. This method will initialize the field if needed. |
| * |
| * @return textTypeToNative |
| */ |
| private synchronized Map<String, LinkedHashSet<String>> getTextTypeToNative() { |
| if (!isMapInitialized) { |
| initSystemFlavorMap(); |
| // From this point the map should not be modified |
| textTypeToNative = Collections.unmodifiableMap(textTypeToNative); |
| } |
| return textTypeToNative; |
| } |
| |
| /** |
| * Caches the result of getNativesForFlavor(). Maps DataFlavors to |
| * SoftReferences which reference LinkedHashSet of String natives. |
| */ |
| private final SoftCache<DataFlavor, String> nativesForFlavorCache = new SoftCache<>(); |
| |
| /** |
| * Caches the result getFlavorsForNative(). Maps String natives to |
| * SoftReferences which reference LinkedHashSet of DataFlavors. |
| */ |
| private final SoftCache<String, DataFlavor> flavorsForNativeCache = new SoftCache<>(); |
| |
| /** |
| * Dynamic mapping generation used for text mappings should not be applied |
| * to the DataFlavors and String natives for which the mappings have been |
| * explicitly specified with {@link #setFlavorsForNative} or |
| * {@link #setNativesForFlavor}. This keeps all such keys. |
| */ |
| private Set<Object> disabledMappingGenerationKeys = new HashSet<>(); |
| |
| /** |
| * Returns the default FlavorMap for this thread's ClassLoader. |
| * |
| * @return the default FlavorMap for this thread's ClassLoader |
| */ |
| public static FlavorMap getDefaultFlavorMap() { |
| return DataFlavorUtil.getDesktopService().getFlavorMap(SystemFlavorMap::new); |
| } |
| |
| private SystemFlavorMap() { |
| } |
| |
| /** |
| * Initializes a SystemFlavorMap by reading {@code flavormap.properties}. |
| * For thread-safety must be called under lock on {@code this}. |
| */ |
| private void initSystemFlavorMap() { |
| if (isMapInitialized) { |
| return; |
| } |
| isMapInitialized = true; |
| |
| InputStream is = AccessController.doPrivileged( |
| (PrivilegedAction<InputStream>) () -> { |
| return SystemFlavorMap.class.getResourceAsStream( |
| "/sun/datatransfer/resources/flavormap.properties"); |
| }); |
| if (is == null) { |
| throw new InternalError("Default flavor mapping not found"); |
| } |
| |
| try (InputStreamReader isr = new InputStreamReader(is); |
| BufferedReader reader = new BufferedReader(isr)) { |
| String line; |
| while ((line = reader.readLine()) != null) { |
| line = line.trim(); |
| if (line.startsWith("#") || line.isEmpty()) continue; |
| while (line.endsWith("\\")) { |
| line = line.substring(0, line.length() - 1) + reader.readLine().trim(); |
| } |
| int delimiterPosition = line.indexOf('='); |
| String key = line.substring(0, delimiterPosition).replace("\\ ", " "); |
| String[] values = line.substring(delimiterPosition + 1, line.length()).split(","); |
| for (String value : values) { |
| try { |
| value = loadConvert(value); |
| MimeType mime = new MimeType(value); |
| if ("text".equals(mime.getPrimaryType())) { |
| String charset = mime.getParameter("charset"); |
| if (DataFlavorUtil.doesSubtypeSupportCharset(mime.getSubType(), charset)) |
| { |
| // We need to store the charset and eoln |
| // parameters, if any, so that the |
| // DataTransferer will have this information |
| // for conversion into the native format. |
| DesktopDatatransferService desktopService = |
| DataFlavorUtil.getDesktopService(); |
| if (desktopService.isDesktopPresent()) { |
| desktopService.registerTextFlavorProperties( |
| key, charset, |
| mime.getParameter("eoln"), |
| mime.getParameter("terminators")); |
| } |
| } |
| |
| // But don't store any of these parameters in the |
| // DataFlavor itself for any text natives (even |
| // non-charset ones). The SystemFlavorMap will |
| // synthesize the appropriate mappings later. |
| mime.removeParameter("charset"); |
| mime.removeParameter("class"); |
| mime.removeParameter("eoln"); |
| mime.removeParameter("terminators"); |
| value = mime.toString(); |
| } |
| } catch (MimeTypeParseException e) { |
| e.printStackTrace(); |
| continue; |
| } |
| |
| DataFlavor flavor; |
| try { |
| flavor = new DataFlavor(value); |
| } catch (Exception e) { |
| try { |
| flavor = new DataFlavor(value, null); |
| } catch (Exception ee) { |
| ee.printStackTrace(); |
| continue; |
| } |
| } |
| |
| final LinkedHashSet<DataFlavor> dfs = new LinkedHashSet<>(); |
| dfs.add(flavor); |
| |
| if ("text".equals(flavor.getPrimaryType())) { |
| dfs.addAll(convertMimeTypeToDataFlavors(value)); |
| store(flavor.mimeType.getBaseType(), key, getTextTypeToNative()); |
| } |
| |
| for (DataFlavor df : dfs) { |
| store(df, key, getFlavorToNative()); |
| store(key, df, getNativeToFlavor()); |
| } |
| } |
| } |
| } catch (IOException e) { |
| throw new InternalError("Error reading default flavor mapping", e); |
| } |
| } |
| |
| // Copied from java.util.Properties |
| private static String loadConvert(String theString) { |
| char aChar; |
| int len = theString.length(); |
| StringBuilder outBuffer = new StringBuilder(len); |
| |
| for (int x = 0; x < len; ) { |
| aChar = theString.charAt(x++); |
| if (aChar == '\\') { |
| aChar = theString.charAt(x++); |
| if (aChar == 'u') { |
| // Read the xxxx |
| int value = 0; |
| for (int i = 0; i < 4; i++) { |
| aChar = theString.charAt(x++); |
| switch (aChar) { |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': { |
| value = (value << 4) + aChar - '0'; |
| break; |
| } |
| case 'a': case 'b': case 'c': |
| case 'd': case 'e': case 'f': { |
| value = (value << 4) + 10 + aChar - 'a'; |
| break; |
| } |
| case 'A': case 'B': case 'C': |
| case 'D': case 'E': case 'F': { |
| value = (value << 4) + 10 + aChar - 'A'; |
| break; |
| } |
| default: { |
| throw new IllegalArgumentException( |
| "Malformed \\uxxxx encoding."); |
| } |
| } |
| } |
| outBuffer.append((char)value); |
| } else { |
| if (aChar == 't') { |
| aChar = '\t'; |
| } else if (aChar == 'r') { |
| aChar = '\r'; |
| } else if (aChar == 'n') { |
| aChar = '\n'; |
| } else if (aChar == 'f') { |
| aChar = '\f'; |
| } |
| outBuffer.append(aChar); |
| } |
| } else { |
| outBuffer.append(aChar); |
| } |
| } |
| return outBuffer.toString(); |
| } |
| |
| /** |
| * Stores the listed object under the specified hash key in map. Unlike a |
| * standard map, the listed object will not replace any object already at |
| * the appropriate Map location, but rather will be appended to a List |
| * stored in that location. |
| */ |
| private <H, L> void store(H hashed, L listed, Map<H, LinkedHashSet<L>> map) { |
| LinkedHashSet<L> list = map.get(hashed); |
| if (list == null) { |
| list = new LinkedHashSet<>(1); |
| map.put(hashed, list); |
| } |
| if (!list.contains(listed)) { |
| list.add(listed); |
| } |
| } |
| |
| /** |
| * Semantically equivalent to 'nativeToFlavor.get(nat)'. This method handles |
| * the case where 'nat' is not found in 'nativeToFlavor'. In that case, a |
| * new DataFlavor is synthesized, stored, and returned, if and only if the |
| * specified native is encoded as a Java MIME type. |
| */ |
| private LinkedHashSet<DataFlavor> nativeToFlavorLookup(String nat) { |
| LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(nat); |
| |
| if (nat != null && !disabledMappingGenerationKeys.contains(nat)) { |
| DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService(); |
| if (desktopService.isDesktopPresent()) { |
| LinkedHashSet<DataFlavor> platformFlavors = |
| desktopService.getPlatformMappingsForNative(nat); |
| if (!platformFlavors.isEmpty()) { |
| if (flavors != null) { |
| // Prepending the platform-specific mappings ensures |
| // that the flavors added with |
| // addFlavorForUnencodedNative() are at the end of |
| // list. |
| platformFlavors.addAll(flavors); |
| } |
| flavors = platformFlavors; |
| } |
| } |
| } |
| |
| if (flavors == null && isJavaMIMEType(nat)) { |
| String decoded = decodeJavaMIMEType(nat); |
| DataFlavor flavor = null; |
| |
| try { |
| flavor = new DataFlavor(decoded); |
| } catch (Exception e) { |
| System.err.println("Exception \"" + e.getClass().getName() + |
| ": " + e.getMessage() + |
| "\"while constructing DataFlavor for: " + |
| decoded); |
| } |
| |
| if (flavor != null) { |
| flavors = new LinkedHashSet<>(1); |
| getNativeToFlavor().put(nat, flavors); |
| flavors.add(flavor); |
| flavorsForNativeCache.remove(nat); |
| |
| LinkedHashSet<String> natives = getFlavorToNative().get(flavor); |
| if (natives == null) { |
| natives = new LinkedHashSet<>(1); |
| getFlavorToNative().put(flavor, natives); |
| } |
| natives.add(nat); |
| nativesForFlavorCache.remove(flavor); |
| } |
| } |
| |
| return (flavors != null) ? flavors : new LinkedHashSet<>(0); |
| } |
| |
| /** |
| * Semantically equivalent to 'flavorToNative.get(flav)'. This method |
| * handles the case where 'flav' is not found in 'flavorToNative' depending |
| * on the value of passes 'synthesize' parameter. If 'synthesize' is |
| * SYNTHESIZE_IF_NOT_FOUND a native is synthesized, stored, and returned by |
| * encoding the DataFlavor's MIME type. Otherwise an empty List is returned |
| * and 'flavorToNative' remains unaffected. |
| */ |
| private LinkedHashSet<String> flavorToNativeLookup(final DataFlavor flav, |
| final boolean synthesize) { |
| |
| LinkedHashSet<String> natives = getFlavorToNative().get(flav); |
| |
| if (flav != null && !disabledMappingGenerationKeys.contains(flav)) { |
| DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService(); |
| if (desktopService.isDesktopPresent()) { |
| LinkedHashSet<String> platformNatives = |
| desktopService.getPlatformMappingsForFlavor(flav); |
| if (!platformNatives.isEmpty()) { |
| if (natives != null) { |
| // Prepend the platform-specific mappings to ensure |
| // that the natives added with |
| // addUnencodedNativeForFlavor() are at the end of |
| // list. |
| platformNatives.addAll(natives); |
| } |
| natives = platformNatives; |
| } |
| } |
| } |
| |
| if (natives == null) { |
| if (synthesize) { |
| String encoded = encodeDataFlavor(flav); |
| natives = new LinkedHashSet<>(1); |
| getFlavorToNative().put(flav, natives); |
| natives.add(encoded); |
| |
| LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(encoded); |
| if (flavors == null) { |
| flavors = new LinkedHashSet<>(1); |
| getNativeToFlavor().put(encoded, flavors); |
| } |
| flavors.add(flav); |
| |
| nativesForFlavorCache.remove(flav); |
| flavorsForNativeCache.remove(encoded); |
| } else { |
| natives = new LinkedHashSet<>(0); |
| } |
| } |
| |
| return new LinkedHashSet<>(natives); |
| } |
| |
| /** |
| * Returns a {@code List} of {@code String} natives to which the specified |
| * {@code DataFlavor} can be translated by the data transfer subsystem. The |
| * {@code List} will be sorted from best native to worst. That is, the first |
| * native will best reflect data in the specified flavor to the underlying |
| * native platform. |
| * <p> |
| * If the specified {@code DataFlavor} is previously unknown to the data |
| * transfer subsystem and the data transfer subsystem is unable to translate |
| * this {@code DataFlavor} to any existing native, then invoking this method |
| * will establish a mapping in both directions between the specified |
| * {@code DataFlavor} and an encoded version of its MIME type as its native. |
| * |
| * @param flav the {@code DataFlavor} whose corresponding natives should be |
| * returned. If {@code null} is specified, all natives currently |
| * known to the data transfer subsystem are returned in a |
| * non-deterministic order. |
| * @return a {@code java.util.List} of {@code java.lang.String} objects |
| * which are platform-specific representations of platform-specific |
| * data formats |
| * @see #encodeDataFlavor |
| * @since 1.4 |
| */ |
| @Override |
| public synchronized List<String> getNativesForFlavor(DataFlavor flav) { |
| LinkedHashSet<String> retval = nativesForFlavorCache.check(flav); |
| if (retval != null) { |
| return new ArrayList<>(retval); |
| } |
| |
| if (flav == null) { |
| retval = new LinkedHashSet<>(getNativeToFlavor().keySet()); |
| } else if (disabledMappingGenerationKeys.contains(flav)) { |
| // In this case we shouldn't synthesize a native for this flavor, |
| // since its mappings were explicitly specified. |
| retval = flavorToNativeLookup(flav, false); |
| } else if (DataFlavorUtil.isFlavorCharsetTextType(flav)) { |
| retval = new LinkedHashSet<>(0); |
| |
| // For text/* flavors, flavor-to-native mappings specified in |
| // flavormap.properties are stored per flavor's base type. |
| if ("text".equals(flav.getPrimaryType())) { |
| LinkedHashSet<String> textTypeNatives = |
| getTextTypeToNative().get(flav.mimeType.getBaseType()); |
| if (textTypeNatives != null) { |
| retval.addAll(textTypeNatives); |
| } |
| } |
| |
| // Also include text/plain natives, but don't duplicate Strings |
| LinkedHashSet<String> textTypeNatives = |
| getTextTypeToNative().get(TEXT_PLAIN_BASE_TYPE); |
| if (textTypeNatives != null) { |
| retval.addAll(textTypeNatives); |
| } |
| |
| if (retval.isEmpty()) { |
| retval = flavorToNativeLookup(flav, true); |
| } else { |
| // In this branch it is guaranteed that natives explicitly |
| // listed for flav's MIME type were added with |
| // addUnencodedNativeForFlavor(), so they have lower priority. |
| retval.addAll(flavorToNativeLookup(flav, false)); |
| } |
| } else if (DataFlavorUtil.isFlavorNoncharsetTextType(flav)) { |
| retval = getTextTypeToNative().get(flav.mimeType.getBaseType()); |
| |
| if (retval == null || retval.isEmpty()) { |
| retval = flavorToNativeLookup(flav, true); |
| } else { |
| // In this branch it is guaranteed that natives explicitly |
| // listed for flav's MIME type were added with |
| // addUnencodedNativeForFlavor(), so they have lower priority. |
| retval.addAll(flavorToNativeLookup(flav, false)); |
| } |
| } else { |
| retval = flavorToNativeLookup(flav, true); |
| } |
| |
| nativesForFlavorCache.put(flav, retval); |
| // Create a copy, because client code can modify the returned list. |
| return new ArrayList<>(retval); |
| } |
| |
| /** |
| * Returns a {@code List} of {@code DataFlavor}s to which the specified |
| * {@code String} native can be translated by the data transfer subsystem. |
| * The {@code List} will be sorted from best {@code DataFlavor} to worst. |
| * That is, the first {@code DataFlavor} will best reflect data in the |
| * specified native to a Java application. |
| * <p> |
| * If the specified native is previously unknown to the data transfer |
| * subsystem, and that native has been properly encoded, then invoking this |
| * method will establish a mapping in both directions between the specified |
| * native and a {@code DataFlavor} whose MIME type is a decoded version of |
| * the native. |
| * <p> |
| * If the specified native is not a properly encoded native and the mappings |
| * for this native have not been altered with {@code setFlavorsForNative}, |
| * then the contents of the {@code List} is platform dependent, but |
| * {@code null} cannot be returned. |
| * |
| * @param nat the native whose corresponding {@code DataFlavor}s should be |
| * returned. If {@code null} is specified, all {@code DataFlavor}s |
| * currently known to the data transfer subsystem are returned in a |
| * non-deterministic order. |
| * @return a {@code java.util.List} of {@code DataFlavor} objects into which |
| * platform-specific data in the specified, platform-specific native |
| * can be translated |
| * @see #encodeJavaMIMEType |
| * @since 1.4 |
| */ |
| @Override |
| public synchronized List<DataFlavor> getFlavorsForNative(String nat) { |
| LinkedHashSet<DataFlavor> returnValue = flavorsForNativeCache.check(nat); |
| if (returnValue != null) { |
| return new ArrayList<>(returnValue); |
| } else { |
| returnValue = new LinkedHashSet<>(); |
| } |
| |
| if (nat == null) { |
| for (String n : getNativesForFlavor(null)) { |
| returnValue.addAll(getFlavorsForNative(n)); |
| } |
| } else { |
| final LinkedHashSet<DataFlavor> flavors = nativeToFlavorLookup(nat); |
| if (disabledMappingGenerationKeys.contains(nat)) { |
| return new ArrayList<>(flavors); |
| } |
| |
| final LinkedHashSet<DataFlavor> flavorsWithSynthesized = |
| nativeToFlavorLookup(nat); |
| |
| for (DataFlavor df : flavorsWithSynthesized) { |
| returnValue.add(df); |
| if ("text".equals(df.getPrimaryType())) { |
| String baseType = df.mimeType.getBaseType(); |
| returnValue.addAll(convertMimeTypeToDataFlavors(baseType)); |
| } |
| } |
| } |
| flavorsForNativeCache.put(nat, returnValue); |
| return new ArrayList<>(returnValue); |
| } |
| |
| @SuppressWarnings("deprecation") |
| private static Set<DataFlavor> convertMimeTypeToDataFlavors( |
| final String baseType) { |
| |
| final Set<DataFlavor> returnValue = new LinkedHashSet<>(); |
| |
| String subType = null; |
| |
| try { |
| final MimeType mimeType = new MimeType(baseType); |
| subType = mimeType.getSubType(); |
| } catch (MimeTypeParseException mtpe) { |
| // Cannot happen, since we checked all mappings |
| // on load from flavormap.properties. |
| } |
| |
| if (DataFlavorUtil.doesSubtypeSupportCharset(subType, null)) { |
| if (TEXT_PLAIN_BASE_TYPE.equals(baseType)) |
| { |
| returnValue.add(DataFlavor.stringFlavor); |
| } |
| |
| for (String unicodeClassName : UNICODE_TEXT_CLASSES) { |
| final String mimeType = baseType + ";charset=Unicode;class=" + |
| unicodeClassName; |
| |
| final LinkedHashSet<String> mimeTypes = |
| handleHtmlMimeTypes(baseType, mimeType); |
| for (String mt : mimeTypes) { |
| DataFlavor toAdd = null; |
| try { |
| toAdd = new DataFlavor(mt); |
| } catch (ClassNotFoundException cannotHappen) { |
| } |
| returnValue.add(toAdd); |
| } |
| } |
| |
| for (String charset : DataFlavorUtil.standardEncodings()) { |
| |
| for (String encodedTextClass : ENCODED_TEXT_CLASSES) { |
| final String mimeType = |
| baseType + ";charset=" + charset + |
| ";class=" + encodedTextClass; |
| |
| final LinkedHashSet<String> mimeTypes = |
| handleHtmlMimeTypes(baseType, mimeType); |
| |
| for (String mt : mimeTypes) { |
| |
| DataFlavor df = null; |
| |
| try { |
| df = new DataFlavor(mt); |
| // Check for equality to plainTextFlavor so |
| // that we can ensure that the exact charset of |
| // plainTextFlavor, not the canonical charset |
| // or another equivalent charset with a |
| // different name, is used. |
| if (df.equals(DataFlavor.plainTextFlavor)) { |
| df = DataFlavor.plainTextFlavor; |
| } |
| } catch (ClassNotFoundException cannotHappen) { |
| } |
| |
| returnValue.add(df); |
| } |
| } |
| } |
| |
| if (TEXT_PLAIN_BASE_TYPE.equals(baseType)) |
| { |
| returnValue.add(DataFlavor.plainTextFlavor); |
| } |
| } else { |
| // Non-charset text natives should be treated as |
| // opaque, 8-bit data in any of its various |
| // representations. |
| for (String encodedTextClassName : ENCODED_TEXT_CLASSES) { |
| DataFlavor toAdd = null; |
| try { |
| toAdd = new DataFlavor(baseType + |
| ";class=" + encodedTextClassName); |
| } catch (ClassNotFoundException cannotHappen) { |
| } |
| returnValue.add(toAdd); |
| } |
| } |
| return returnValue; |
| } |
| |
| private static final String [] htmlDocumentTypes = |
| new String [] {"all", "selection", "fragment"}; |
| |
| private static LinkedHashSet<String> handleHtmlMimeTypes(String baseType, |
| String mimeType) { |
| |
| LinkedHashSet<String> returnValues = new LinkedHashSet<>(); |
| |
| if (HTML_TEXT_BASE_TYPE.equals(baseType)) { |
| for (String documentType : htmlDocumentTypes) { |
| returnValues.add(mimeType + ";document=" + documentType); |
| } |
| } else { |
| returnValues.add(mimeType); |
| } |
| |
| return returnValues; |
| } |
| |
| /** |
| * Returns a {@code Map} of the specified {@code DataFlavor}s to their most |
| * preferred {@code String} native. Each native value will be the same as |
| * the first native in the List returned by {@code getNativesForFlavor} for |
| * the specified flavor. |
| * <p> |
| * If a specified {@code DataFlavor} is previously unknown to the data |
| * transfer subsystem, then invoking this method will establish a mapping in |
| * both directions between the specified {@code DataFlavor} and an encoded |
| * version of its MIME type as its native. |
| * |
| * @param flavors an array of {@code DataFlavor}s which will be the key set |
| * of the returned {@code Map}. If {@code null} is specified, a |
| * mapping of all {@code DataFlavor}s known to the data transfer |
| * subsystem to their most preferred {@code String} natives will be |
| * returned. |
| * @return a {@code java.util.Map} of {@code DataFlavor}s to {@code String} |
| * natives |
| * @see #getNativesForFlavor |
| * @see #encodeDataFlavor |
| */ |
| @Override |
| public synchronized Map<DataFlavor,String> getNativesForFlavors(DataFlavor[] flavors) |
| { |
| // Use getNativesForFlavor to generate extra natives for text flavors |
| // and stringFlavor |
| |
| if (flavors == null) { |
| List<DataFlavor> flavor_list = getFlavorsForNative(null); |
| flavors = new DataFlavor[flavor_list.size()]; |
| flavor_list.toArray(flavors); |
| } |
| |
| Map<DataFlavor, String> retval = new HashMap<>(flavors.length, 1.0f); |
| for (DataFlavor flavor : flavors) { |
| List<String> natives = getNativesForFlavor(flavor); |
| String nat = (natives.isEmpty()) ? null : natives.get(0); |
| retval.put(flavor, nat); |
| } |
| |
| return retval; |
| } |
| |
| /** |
| * Returns a {@code Map} of the specified {@code String} natives to their |
| * most preferred {@code DataFlavor}. Each {@code DataFlavor} value will be |
| * the same as the first {@code DataFlavor} in the List returned by |
| * {@code getFlavorsForNative} for the specified native. |
| * <p> |
| * If a specified native is previously unknown to the data transfer |
| * subsystem, and that native has been properly encoded, then invoking this |
| * method will establish a mapping in both directions between the specified |
| * native and a {@code DataFlavor} whose MIME type is a decoded version of |
| * the native. |
| * |
| * @param natives an array of {@code String}s which will be the key set of |
| * the returned {@code Map}. If {@code null} is specified, a mapping |
| * of all supported {@code String} natives to their most preferred |
| * {@code DataFlavor}s will be returned. |
| * @return a {@code java.util.Map} of {@code String} natives to |
| * {@code DataFlavor}s |
| * @see #getFlavorsForNative |
| * @see #encodeJavaMIMEType |
| */ |
| @Override |
| public synchronized Map<String,DataFlavor> getFlavorsForNatives(String[] natives) |
| { |
| // Use getFlavorsForNative to generate extra flavors for text natives |
| if (natives == null) { |
| List<String> nativesList = getNativesForFlavor(null); |
| natives = new String[nativesList.size()]; |
| nativesList.toArray(natives); |
| } |
| |
| Map<String, DataFlavor> retval = new HashMap<>(natives.length, 1.0f); |
| for (String aNative : natives) { |
| List<DataFlavor> flavors = getFlavorsForNative(aNative); |
| DataFlavor flav = (flavors.isEmpty())? null : flavors.get(0); |
| retval.put(aNative, flav); |
| } |
| return retval; |
| } |
| |
| /** |
| * Adds a mapping from the specified {@code DataFlavor} (and all |
| * {@code DataFlavor}s equal to the specified {@code DataFlavor}) to the |
| * specified {@code String} native. Unlike {@code getNativesForFlavor}, the |
| * mapping will only be established in one direction, and the native will |
| * not be encoded. To establish a two-way mapping, call |
| * {@code addFlavorForUnencodedNative} as well. The new mapping will be of |
| * lower priority than any existing mapping. This method has no effect if a |
| * mapping from the specified or equal {@code DataFlavor} to the specified |
| * {@code String} native already exists. |
| * |
| * @param flav the {@code DataFlavor} key for the mapping |
| * @param nat the {@code String} native value for the mapping |
| * @throws NullPointerException if flav or nat is {@code null} |
| * @see #addFlavorForUnencodedNative |
| * @since 1.4 |
| */ |
| public synchronized void addUnencodedNativeForFlavor(DataFlavor flav, |
| String nat) { |
| Objects.requireNonNull(nat, "Null native not permitted"); |
| Objects.requireNonNull(flav, "Null flavor not permitted"); |
| |
| LinkedHashSet<String> natives = getFlavorToNative().get(flav); |
| if (natives == null) { |
| natives = new LinkedHashSet<>(1); |
| getFlavorToNative().put(flav, natives); |
| } |
| natives.add(nat); |
| nativesForFlavorCache.remove(flav); |
| } |
| |
| /** |
| * Discards the current mappings for the specified {@code DataFlavor} and |
| * all {@code DataFlavor}s equal to the specified {@code DataFlavor}, and |
| * creates new mappings to the specified {@code String} natives. Unlike |
| * {@code getNativesForFlavor}, the mappings will only be established in one |
| * direction, and the natives will not be encoded. To establish two-way |
| * mappings, call {@code setFlavorsForNative} as well. The first native in |
| * the array will represent the highest priority mapping. Subsequent natives |
| * will represent mappings of decreasing priority. |
| * <p> |
| * If the array contains several elements that reference equal |
| * {@code String} natives, this method will establish new mappings for the |
| * first of those elements and ignore the rest of them. |
| * <p> |
| * It is recommended that client code not reset mappings established by the |
| * data transfer subsystem. This method should only be used for |
| * application-level mappings. |
| * |
| * @param flav the {@code DataFlavor} key for the mappings |
| * @param natives the {@code String} native values for the mappings |
| * @throws NullPointerException if flav or natives is {@code null} or if |
| * natives contains {@code null} elements |
| * @see #setFlavorsForNative |
| * @since 1.4 |
| */ |
| public synchronized void setNativesForFlavor(DataFlavor flav, |
| String[] natives) { |
| Objects.requireNonNull(natives, "Null natives not permitted"); |
| Objects.requireNonNull(flav, "Null flavors not permitted"); |
| |
| getFlavorToNative().remove(flav); |
| for (String aNative : natives) { |
| addUnencodedNativeForFlavor(flav, aNative); |
| } |
| disabledMappingGenerationKeys.add(flav); |
| nativesForFlavorCache.remove(flav); |
| } |
| |
| /** |
| * Adds a mapping from a single {@code String} native to a single |
| * {@code DataFlavor}. Unlike {@code getFlavorsForNative}, the mapping will |
| * only be established in one direction, and the native will not be encoded. |
| * To establish a two-way mapping, call {@code addUnencodedNativeForFlavor} |
| * as well. The new mapping will be of lower priority than any existing |
| * mapping. This method has no effect if a mapping from the specified |
| * {@code String} native to the specified or equal {@code DataFlavor} |
| * already exists. |
| * |
| * @param nat the {@code String} native key for the mapping |
| * @param flav the {@code DataFlavor} value for the mapping |
| * @throws NullPointerException if {@code nat} or {@code flav} is |
| * {@code null} |
| * @see #addUnencodedNativeForFlavor |
| * @since 1.4 |
| */ |
| public synchronized void addFlavorForUnencodedNative(String nat, |
| DataFlavor flav) { |
| Objects.requireNonNull(nat, "Null native not permitted"); |
| Objects.requireNonNull(flav, "Null flavor not permitted"); |
| |
| LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(nat); |
| if (flavors == null) { |
| flavors = new LinkedHashSet<>(1); |
| getNativeToFlavor().put(nat, flavors); |
| } |
| flavors.add(flav); |
| flavorsForNativeCache.remove(nat); |
| } |
| |
| /** |
| * Discards the current mappings for the specified {@code String} native, |
| * and creates new mappings to the specified {@code DataFlavor}s. Unlike |
| * {@code getFlavorsForNative}, the mappings will only be established in one |
| * direction, and the natives need not be encoded. To establish two-way |
| * mappings, call {@code setNativesForFlavor} as well. The first |
| * {@code DataFlavor} in the array will represent the highest priority |
| * mapping. Subsequent {@code DataFlavor}s will represent mappings of |
| * decreasing priority. |
| * <p> |
| * If the array contains several elements that reference equal |
| * {@code DataFlavor}s, this method will establish new mappings for the |
| * first of those elements and ignore the rest of them. |
| * <p> |
| * It is recommended that client code not reset mappings established by the |
| * data transfer subsystem. This method should only be used for |
| * application-level mappings. |
| * |
| * @param nat the {@code String} native key for the mappings |
| * @param flavors the {@code DataFlavor} values for the mappings |
| * @throws NullPointerException if {@code nat} or {@code flavors} is |
| * {@code null} or if {@code flavors} contains {@code null} elements |
| * @see #setNativesForFlavor |
| * @since 1.4 |
| */ |
| public synchronized void setFlavorsForNative(String nat, |
| DataFlavor[] flavors) { |
| Objects.requireNonNull(nat, "Null native not permitted"); |
| Objects.requireNonNull(flavors, "Null flavors not permitted"); |
| |
| getNativeToFlavor().remove(nat); |
| for (DataFlavor flavor : flavors) { |
| addFlavorForUnencodedNative(nat, flavor); |
| } |
| disabledMappingGenerationKeys.add(nat); |
| flavorsForNativeCache.remove(nat); |
| } |
| |
| /** |
| * Encodes a MIME type for use as a {@code String} native. The format of an |
| * encoded representation of a MIME type is implementation-dependent. The |
| * only restrictions are: |
| * <ul> |
| * <li>The encoded representation is {@code null} if and only if the MIME |
| * type {@code String} is {@code null}</li> |
| * <li>The encoded representations for two non-{@code null} MIME type |
| * {@code String}s are equal if and only if these {@code String}s are |
| * equal according to {@code String.equals(Object)}</li> |
| * </ul> |
| * The reference implementation of this method returns the specified MIME |
| * type {@code String} prefixed with {@code JAVA_DATAFLAVOR:}. |
| * |
| * @param mimeType the MIME type to encode |
| * @return the encoded {@code String}, or {@code null} if {@code mimeType} |
| * is {@code null} |
| */ |
| public static String encodeJavaMIMEType(String mimeType) { |
| return (mimeType != null) |
| ? JavaMIME + mimeType |
| : null; |
| } |
| |
| /** |
| * Encodes a {@code DataFlavor} for use as a {@code String} native. The |
| * format of an encoded {@code DataFlavor} is implementation-dependent. The |
| * only restrictions are: |
| * <ul> |
| * <li>The encoded representation is {@code null} if and only if the |
| * specified {@code DataFlavor} is {@code null} or its MIME type |
| * {@code String} is {@code null}</li> |
| * <li>The encoded representations for two non-{@code null} |
| * {@code DataFlavor}s with non-{@code null} MIME type {@code String}s |
| * are equal if and only if the MIME type {@code String}s of these |
| * {@code DataFlavor}s are equal according to |
| * {@code String.equals(Object)}</li> |
| * </ul> |
| * The reference implementation of this method returns the MIME type |
| * {@code String} of the specified {@code DataFlavor} prefixed with |
| * {@code JAVA_DATAFLAVOR:}. |
| * |
| * @param flav the {@code DataFlavor} to encode |
| * @return the encoded {@code String}, or {@code null} if {@code flav} is |
| * {@code null} or has a {@code null} MIME type |
| */ |
| public static String encodeDataFlavor(DataFlavor flav) { |
| return (flav != null) |
| ? SystemFlavorMap.encodeJavaMIMEType(flav.getMimeType()) |
| : null; |
| } |
| |
| /** |
| * Returns whether the specified {@code String} is an encoded Java MIME |
| * type. |
| * |
| * @param str the {@code String} to test |
| * @return {@code true} if the {@code String} is encoded; {@code false} |
| * otherwise |
| */ |
| public static boolean isJavaMIMEType(String str) { |
| return (str != null && str.startsWith(JavaMIME, 0)); |
| } |
| |
| /** |
| * Decodes a {@code String} native for use as a Java MIME type. |
| * |
| * @param nat the {@code String} to decode |
| * @return the decoded Java MIME type, or {@code null} if {@code nat} is not |
| * an encoded {@code String} native |
| */ |
| public static String decodeJavaMIMEType(String nat) { |
| return (isJavaMIMEType(nat)) |
| ? nat.substring(JavaMIME.length(), nat.length()).trim() |
| : null; |
| } |
| |
| /** |
| * Decodes a {@code String} native for use as a {@code DataFlavor}. |
| * |
| * @param nat the {@code String} to decode |
| * @return the decoded {@code DataFlavor}, or {@code null} if {@code nat} is |
| * not an encoded {@code String} native |
| * @throws ClassNotFoundException if the class of the data flavor is not |
| * loaded |
| */ |
| public static DataFlavor decodeDataFlavor(String nat) |
| throws ClassNotFoundException |
| { |
| String retval_str = SystemFlavorMap.decodeJavaMIMEType(nat); |
| return (retval_str != null) |
| ? new DataFlavor(retval_str) |
| : null; |
| } |
| |
| private static final class SoftCache<K, V> { |
| Map<K, SoftReference<LinkedHashSet<V>>> cache; |
| |
| public void put(K key, LinkedHashSet<V> value) { |
| if (cache == null) { |
| cache = new HashMap<>(1); |
| } |
| cache.put(key, new SoftReference<>(value)); |
| } |
| |
| public void remove(K key) { |
| if (cache == null) return; |
| cache.remove(null); |
| cache.remove(key); |
| } |
| |
| public LinkedHashSet<V> check(K key) { |
| if (cache == null) return null; |
| SoftReference<LinkedHashSet<V>> ref = cache.get(key); |
| if (ref != null) { |
| return ref.get(); |
| } |
| return null; |
| } |
| } |
| } |
