| /* |
| * Copyright (c) 1997, 2012, 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 javax.activation; |
| |
| import java.awt.datatransfer.DataFlavor; |
| import java.io.IOException; |
| import javax.activation.MimeType; |
| |
| /** |
| * The ActivationDataFlavor class is a special subclass of |
| * {@code java.awt.datatransfer.DataFlavor}. It allows the JAF to |
| * set all three values stored by the DataFlavor class via a new |
| * constructor. It also contains improved MIME parsing in the {@code equals} |
| * method. Except for the improved parsing, its semantics are |
| * identical to that of the JDK's DataFlavor class. |
| * |
| * @since 1.6 |
| */ |
| |
| public class ActivationDataFlavor extends DataFlavor { |
| |
| /* |
| * Raison d'etre: |
| * |
| * The DataFlavor class included in JDK 1.1 has several limitations |
| * including piss poor MIME type parsing, and the limitation of |
| * only supporting serialized objects and InputStreams as |
| * representation objects. This class 'fixes' that. |
| */ |
| |
| // I think for now I'll keep copies of all the variables and |
| // then later I may choose try to better coexist with the base |
| // class *sigh* |
| private String mimeType = null; |
| private MimeType mimeObject = null; |
| private String humanPresentableName = null; |
| private Class representationClass = null; |
| |
| /** |
| * Construct a DataFlavor that represents an arbitrary |
| * Java object. This constructor is an extension of the |
| * JDK's DataFlavor in that it allows the explicit setting |
| * of all three DataFlavor attributes. |
| * <p> |
| * The returned DataFlavor will have the following characteristics: |
| * <p> |
| * representationClass = representationClass<br> |
| * mimeType = mimeType<br> |
| * humanName = humanName |
| * |
| * @param representationClass the class used in this DataFlavor |
| * @param mimeType the MIME type of the data represented by this class |
| * @param humanPresentableName the human presentable name of the flavor |
| */ |
| public ActivationDataFlavor(Class representationClass, |
| String mimeType, String humanPresentableName) { |
| super(mimeType, humanPresentableName); // need to call super |
| |
| // init private variables: |
| this.mimeType = mimeType; |
| this.humanPresentableName = humanPresentableName; |
| this.representationClass = representationClass; |
| } |
| |
| /** |
| * Construct a DataFlavor that represents a MimeType. |
| * <p> |
| * The returned DataFlavor will have the following characteristics: |
| * <p> |
| * If the mimeType is "application/x-java-serialized-object; |
| * class=", the result is the same as calling new |
| * DataFlavor(Class.forName()) as above. |
| * <p> |
| * otherwise: |
| * <p> |
| * representationClass = InputStream<p> |
| * mimeType = mimeType |
| * |
| * @param representationClass the class used in this DataFlavor |
| * @param humanPresentableName the human presentable name of the flavor |
| */ |
| public ActivationDataFlavor(Class representationClass, |
| String humanPresentableName) { |
| super(representationClass, humanPresentableName); |
| this.mimeType = super.getMimeType(); |
| this.representationClass = representationClass; |
| this.humanPresentableName = humanPresentableName; |
| } |
| |
| /** |
| * Construct a DataFlavor that represents a MimeType. |
| * <p> |
| * The returned DataFlavor will have the following characteristics: |
| * <p> |
| * If the mimeType is "application/x-java-serialized-object; class=", |
| * the result is the same as calling new DataFlavor(Class.forName()) as |
| * above, otherwise: |
| * <p> |
| * representationClass = InputStream<p> |
| * mimeType = mimeType |
| * |
| * @param mimeType the MIME type of the data represented by this class |
| * @param humanPresentableName the human presentable name of the flavor |
| */ |
| public ActivationDataFlavor(String mimeType, String humanPresentableName) { |
| super(mimeType, humanPresentableName); |
| this.mimeType = mimeType; |
| try { |
| this.representationClass = Class.forName("java.io.InputStream"); |
| } catch (ClassNotFoundException ex) { |
| // XXX - should never happen, ignore it |
| } |
| this.humanPresentableName = humanPresentableName; |
| } |
| |
| /** |
| * Return the MIME type for this DataFlavor. |
| * |
| * @return the MIME type |
| */ |
| public String getMimeType() { |
| return mimeType; |
| } |
| |
| /** |
| * Return the representation class. |
| * |
| * @return the representation class |
| */ |
| public Class getRepresentationClass() { |
| return representationClass; |
| } |
| |
| /** |
| * Return the Human Presentable name. |
| * |
| * @return the human presentable name |
| */ |
| public String getHumanPresentableName() { |
| return humanPresentableName; |
| } |
| |
| /** |
| * Set the human presentable name. |
| * |
| * @param humanPresentableName the name to set |
| */ |
| public void setHumanPresentableName(String humanPresentableName) { |
| this.humanPresentableName = humanPresentableName; |
| } |
| |
| /** |
| * 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); |
| } |
| |
| /** |
| * Is the string representation of the MIME type passed in equivalent |
| * to the MIME type of this DataFlavor. <p> |
| * |
| * ActivationDataFlavor delegates the comparison of MIME types to |
| * the MimeType class included as part of the JavaBeans Activation |
| * Framework. This provides a more robust comparison than is normally |
| * available in the DataFlavor class. |
| * |
| * @param mimeType the MIME type |
| * @return true if the same MIME type |
| */ |
| public boolean isMimeTypeEqual(String mimeType) { |
| MimeType mt = null; |
| try { |
| if (mimeObject == null) |
| mimeObject = new MimeType(this.mimeType); |
| mt = new MimeType(mimeType); |
| } catch (MimeTypeParseException e) { |
| // something didn't parse, do a crude comparison |
| return this.mimeType.equalsIgnoreCase(mimeType); |
| } |
| |
| return mimeObject.match(mt); |
| } |
| |
| /** |
| * 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). |
| * <p> |
| * 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. |
| * |
| * @param parameterName the parameter name |
| * @param parameterValue the parameter value |
| * @return the normalized parameter value |
| * @deprecated |
| */ |
| protected String normalizeMimeTypeParameter(String parameterName, |
| String parameterValue) { |
| return parameterValue; |
| } |
| |
| /** |
| * 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. |
| * |
| * @param mimeType the MIME type |
| * @return the normalized MIME type |
| * @deprecated |
| */ |
| protected String normalizeMimeType(String mimeType) { |
| return mimeType; |
| } |
| } |