| /* DocFlavor.java -- |
| Copyright (C) 2004, 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package javax.print; |
| |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.io.Serializable; |
| import java.io.StreamTokenizer; |
| import java.io.StringReader; |
| import java.nio.charset.Charset; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.TreeMap; |
| |
| /** |
| * <code>DocFlavor</code> provides a description of the format in which the |
| * print data will be supplied in a print job to the print service. |
| * <p> |
| * A doc flavor consists of two parts: |
| * <ul> |
| * <li> |
| * The MIME type (Multipurpose Internet Mail Extensions types as described |
| * in RFC 2045/2046) specifying the media format of the print data. |
| * </li><li> |
| * The representation class name which is the fully qualified name of the |
| * class providing the print data to the print job. For example if the print |
| * data is supplied as a byte array the representation class name will be |
| * <code>"[B"</code> or for an input stream <code>"java.io.InputStream"</code>. |
| * </li> |
| * </ul> |
| * The <code>DocFlavor</code> class is therefore used in several places in the |
| * Java Print Service API. A print service provides its supported document |
| * flavors as an array of DocFlavor objects and a print job gets the flavor of |
| * its data to print from the <code>Doc</code> object provided as a DocFlavor |
| * instance. |
| * </p> |
| * <p> |
| * It has to be differentiated between <b>client formatted</b> and <b>service |
| * formatted</b> print data. Client formatted print data is already provided |
| * formatted by the client e.g. in an image format or as postscript. For |
| * service formatted print data, the Java Print Service instance produces |
| * the formatted print data. Here the doc flavor's representation class name |
| * does specify an interface instead of the actual print data source. The |
| * print service will call the methods of the given implementation of this |
| * interface with a special Graphics object capable of producing formatted |
| * print data from the graphics routines inside the interface methods. |
| * </p> |
| * <p> |
| * <h3>Client formatted print data document flavors</h3> |
| * The print service uses the representation class of the doc flavor to know |
| * how to retrieve the print data. If the representation class is a |
| * <code>URL</code> it will open the URL to read the print data from it. If it is |
| * a <code>byte[]</code> it will directly use the array and send it to the |
| * printer. There are predefined doc flavor as inner class for the most common |
| * representation class types: |
| * <ul> |
| * <li>Character arrays (<code>char[]</code>): The characters of the array |
| * represent the print data.</li> |
| * <li>Character streams (<code>java.io.Reader</code>): The whole characters |
| * read from the stream represent the print data.</li> |
| * <li>String (<code>java.lang.String</code>): The characters of the String |
| * represent the print data.</li> |
| * <li>Byte arrays (<code>byte[]</code>): The bytes of the array represent the |
| * print data. Encoding if text content is given in the mime type.</li> |
| * <li>Byte streams (<code>java.io.InputStream</code>): The whole bytes read |
| * from the stream represent the print data. If text content the encoding is |
| * specified in the mime type.</li> |
| * <li>Uniform Resource Locator (<code>java.net.URL</code>): The bytes read |
| * from the stream through opening of the URL represent the print data. |
| * If text content the encoding is specified in the mime type.</li></li> |
| * </ul> |
| * </p> |
| * <p> |
| * <h3>Service formatted print data document flavors</h3> |
| * The print service uses the provided object implementing the interface |
| * specified by the representation class to produce the formatted print data. |
| * The mime type of service formatted data is always |
| * <code>"application/x-java-jvm-local-objectref"</code> to signal the local |
| * reference to the print data object implementing the interface. Predefined |
| * doc flavor classes exist as an inner class for the three available interface |
| * to produce print data: |
| * <ul> |
| * <li>Pageable object (<code>java.awt.print.Pageable</code>): A pageable object |
| * is supplied to the print service. The print service will call the methods of |
| * the interface with a Grahics object to produce the formatted print data.</li> |
| * <li>Printable object (<code>java.awt.print.Printable</code>): A printable object |
| * is supplied to the print service. The print service will call the methods of |
| * the interface with a Grahics object to produce the formatted print data.</li> |
| * <li>Renderable Image object |
| * (<code>java.awt.image.renderable.RenderableImage</code>): A renderable image |
| * object is supplied to the print service. The print service calls methods of |
| * this interface to obtain the image to be printed.</li> |
| * </ul> |
| * </p> |
| * |
| * @author Michael Koch (konqueror@gmx.de) |
| * @author Wolfgang Baer (WBaer@gmx.de) |
| */ |
| public class DocFlavor implements Cloneable, Serializable |
| { |
| /** |
| * Predefined static <code>DocFlavor</code> objects for document |
| * types which use a byte array for the print data representation. |
| * <p>All the defined doc flavors have a print data representation |
| * classname of "[B" (byte array).</p> |
| * |
| * @author Michael Koch (konqueror@gmx.de) |
| */ |
| public static class BYTE_ARRAY |
| extends DocFlavor |
| { |
| private static final long serialVersionUID = -9065578006593857475L; |
| |
| /** |
| * Byte array doc flavor with a MIME Type of "application/octet-stream". |
| */ |
| public static final BYTE_ARRAY AUTOSENSE = new BYTE_ARRAY("application/octet-stream"); |
| /** |
| * Byte array doc flavor with a MIME Type of "image/gif". |
| */ |
| public static final BYTE_ARRAY GIF = new BYTE_ARRAY("image/gif"); |
| /** |
| * Byte array doc flavor with a MIME Type of "image/jpeg". |
| */ |
| public static final BYTE_ARRAY JPEG = new BYTE_ARRAY("image/jpeg"); |
| /** |
| * Byte array doc flavor with a MIME Type of "application/vnd.hp-PCL". |
| */ |
| public static final BYTE_ARRAY PCL = new BYTE_ARRAY("application/vnd.hp-PCL"); |
| /** |
| * Byte array doc flavor with a MIME Type of "application/pdf". |
| */ |
| public static final BYTE_ARRAY PDF = new BYTE_ARRAY("application/pdf"); |
| /** |
| * Byte array doc flavor with a MIME Type of "image/png". |
| */ |
| public static final BYTE_ARRAY PNG = new BYTE_ARRAY("image/png"); |
| /** |
| * Byte array doc flavor with a MIME Type of "application/postscript". |
| */ |
| public static final BYTE_ARRAY POSTSCRIPT = new BYTE_ARRAY("application/postscript"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/html" in the host encoding. |
| */ |
| public static final BYTE_ARRAY TEXT_HTML_HOST = new BYTE_ARRAY("text/html; charset=" + hostEncoding); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/html; charset=us-ascii". |
| */ |
| public static final BYTE_ARRAY TEXT_HTML_US_ASCII = new BYTE_ARRAY("text/html; charset=us-ascii"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/html; charset=utf-16". |
| */ |
| public static final BYTE_ARRAY TEXT_HTML_UTF_16 = new BYTE_ARRAY("text/html; charset=utf-16"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/html; charset=utf-16be". |
| */ |
| public static final BYTE_ARRAY TEXT_HTML_UTF_16BE = new BYTE_ARRAY("text/html; charset=utf-16be"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/html; charset=utf-16le". |
| */ |
| public static final BYTE_ARRAY TEXT_HTML_UTF_16LE = new BYTE_ARRAY("text/html; charset=utf-16le"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/html; charset=utf-8". |
| */ |
| public static final BYTE_ARRAY TEXT_HTML_UTF_8 = new BYTE_ARRAY("text/html; charset=utf-8"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/plain" in the host encoding. |
| */ |
| public static final BYTE_ARRAY TEXT_PLAIN_HOST = new BYTE_ARRAY("text/plain; charset=" + hostEncoding); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/plain; charset=us-ascii". |
| */ |
| public static final BYTE_ARRAY TEXT_PLAIN_US_ASCII = new BYTE_ARRAY("text/plain; charset=us-ascii"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/plain; charset=utf-16". |
| */ |
| public static final BYTE_ARRAY TEXT_PLAIN_UTF_16 = new BYTE_ARRAY("text/plain; charset=utf-16"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/plain; charset=utf-16be". |
| */ |
| public static final BYTE_ARRAY TEXT_PLAIN_UTF_16BE = new BYTE_ARRAY("text/plain; charset=utf-16be"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/plain; charset=utf-16le". |
| */ |
| public static final BYTE_ARRAY TEXT_PLAIN_UTF_16LE = new BYTE_ARRAY("text/plain; charset=utf-16le"); |
| /** |
| * Byte array doc flavor with a MIME Type of "text/plain; charset=utf-8". |
| */ |
| public static final BYTE_ARRAY TEXT_PLAIN_UTF_8 = new BYTE_ARRAY("text/plain; charset=utf-8"); |
| |
| /** |
| * Constructor for doc flavor objects with the given MIME type |
| * and a print data representation class name of "[B". |
| * |
| * @param mimeType the mime type string |
| * |
| * @throws NullPointerException if mimeType is <code>null</code>. |
| * @throws IllegalArgumentException if mimeType has the wrong syntax. |
| */ |
| public BYTE_ARRAY(String mimeType) |
| { |
| super(mimeType, "[B"); |
| } |
| } |
| |
| /** |
| * Predefined static <code>DocFlavor</code> objects for document |
| * types which use a char array for the print data representation. |
| * <p>All the defined doc flavors have a print data representation |
| * classname of "[C" (char array).</p> |
| * |
| * @author Michael Koch (konqueror@gmx.de) |
| */ |
| public static class CHAR_ARRAY |
| extends DocFlavor |
| { |
| private static final long serialVersionUID = -8720590903724405128L; |
| |
| /** |
| * Char array doc flavor with a MIME Type of "text/html; charset=utf-16". |
| */ |
| public static final DocFlavor.CHAR_ARRAY TEXT_HTML = new CHAR_ARRAY("text/html; charset=utf-16"); |
| /** |
| * Char array doc flavor with a MIME Type of "text/plain; charset=utf-16". |
| */ |
| public static final DocFlavor.CHAR_ARRAY TEXT_PLAIN = new CHAR_ARRAY("text/plain; charset=utf-16"); |
| |
| /** |
| * Constructor for doc flavor objects with the given MIME type |
| * and a print data representation class name of "[C". |
| * |
| * @param mimeType the mime type string |
| * |
| * @throws NullPointerException if mimeType is <code>null</code>. |
| * @throws IllegalArgumentException if mimeType has the wrong syntax. |
| */ |
| public CHAR_ARRAY(String mimeType) |
| { |
| super(mimeType, "[C"); |
| } |
| } |
| |
| /** |
| * Predefined static <code>DocFlavor</code> objects for document |
| * types which use an InputStream to retrieve the print data. |
| * <p>All the defined doc flavors have a print data representation |
| * classname of "java.io.InputStream".</p> |
| * |
| * @author Michael Koch (konqueror@gmx.de) |
| */ |
| public static class INPUT_STREAM |
| extends DocFlavor |
| { |
| private static final long serialVersionUID = -7045842700749194127L; |
| |
| /** |
| * InputStream doc flavor with a MIME Type of "application/octet-stream". |
| */ |
| public static final INPUT_STREAM AUTOSENSE = new INPUT_STREAM("application/octet-stream"); |
| /** |
| * InputStream doc flavor with a MIME Type of "image/gif". |
| */ |
| public static final INPUT_STREAM GIF = new INPUT_STREAM("image/gif"); |
| /** |
| * InputStream doc flavor with a MIME Type of "image/jpeg". |
| */ |
| public static final INPUT_STREAM JPEG = new INPUT_STREAM("image/jpeg"); |
| /** |
| * InputStream doc flavor with a MIME Type of "application/vnd.hp-PCL". |
| */ |
| public static final INPUT_STREAM PCL = new INPUT_STREAM("application/vnd.hp-PCL"); |
| /** |
| * InputStream doc flavor with a MIME Type of "application/pdf". |
| */ |
| public static final INPUT_STREAM PDF = new INPUT_STREAM("application/pdf"); |
| /** |
| * InputStream doc flavor with a MIME Type of "image/png". |
| */ |
| public static final INPUT_STREAM PNG = new INPUT_STREAM("image/png"); |
| /** |
| * InputStream doc flavor with a MIME Type of "application/postscript". |
| */ |
| public static final INPUT_STREAM POSTSCRIPT = new INPUT_STREAM("application/postscript"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/html" in the host encoding. |
| */ |
| public static final INPUT_STREAM TEXT_HTML_HOST = new INPUT_STREAM("text/html; charset=" + hostEncoding); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/html; charset=us-ascii". |
| */ |
| public static final INPUT_STREAM TEXT_HTML_US_ASCII = new INPUT_STREAM("text/html; charset=us-ascii"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/html; charset=utf-16". |
| */ |
| public static final INPUT_STREAM TEXT_HTML_UTF_16 = new INPUT_STREAM("text/html; charset=utf-16"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/html; charset=utf-16be". |
| */ |
| public static final INPUT_STREAM TEXT_HTML_UTF_16BE = new INPUT_STREAM("text/html; charset=utf-16be"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/html; charset=utf-16le". |
| */ |
| public static final INPUT_STREAM TEXT_HTML_UTF_16LE = new INPUT_STREAM("text/html; charset=utf-16le"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/html; charset=utf-8". |
| */ |
| public static final INPUT_STREAM TEXT_HTML_UTF_8 = new INPUT_STREAM("text/html; charset=utf-8"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/plain" in the host encoding. |
| */ |
| public static final INPUT_STREAM TEXT_PLAIN_HOST = new INPUT_STREAM("text/plain; charset=" + hostEncoding); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/plain; charset=us-ascii". |
| */ |
| public static final INPUT_STREAM TEXT_PLAIN_US_ASCII = new INPUT_STREAM("text/plain; charset=us-ascii"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/plain; charset=utf-16". |
| */ |
| public static final INPUT_STREAM TEXT_PLAIN_UTF_16 = new INPUT_STREAM("text/plain; charset=utf-16"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/plain; charset=utf-16be". |
| */ |
| public static final INPUT_STREAM TEXT_PLAIN_UTF_16BE = new INPUT_STREAM("text/plain; charset=utf-16be"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/plain; charset=utf-16le". |
| */ |
| public static final INPUT_STREAM TEXT_PLAIN_UTF_16LE = new INPUT_STREAM("text/plain; charset=utf-16le"); |
| /** |
| * InputStream doc flavor with a MIME Type of "text/plain; charset=utf-8". |
| */ |
| public static final INPUT_STREAM TEXT_PLAIN_UTF_8 = new INPUT_STREAM("text/plain; charset=utf-8"); |
| |
| /** |
| * Constructor for doc flavor objects with the given MIME type |
| * and a print data representation class name of "java.io.InputStream". |
| * |
| * @param mimeType the mime type string |
| * |
| * @throws NullPointerException if mimeType is <code>null</code>. |
| * @throws IllegalArgumentException if mimeType has the wrong syntax. |
| */ |
| public INPUT_STREAM(String mimeType) |
| { |
| super(mimeType, "java.io.InputStream"); |
| } |
| } |
| |
| /** |
| * Predefined static <code>DocFlavor</code> objects for document |
| * types which use an Reader to retrieve the print data. |
| * <p>All the defined doc flavors have a print data representation |
| * classname of "java.io.Reader".</p> |
| * |
| * @author Michael Koch (konqueror@gmx.de) |
| */ |
| public static class READER |
| extends DocFlavor |
| { |
| private static final long serialVersionUID = 7100295812579351567L; |
| |
| /** |
| * Reader doc flavor with a MIME Type of "text/html; charset=utf-16". |
| */ |
| public static final DocFlavor.READER TEXT_HTML = new READER("text/html; charset=utf-16"); |
| /** |
| * Reader doc flavor with a MIME Type of "text/plain; charset=utf-16". |
| */ |
| public static final DocFlavor.READER TEXT_PLAIN = new READER("text/plain; charset=utf-16"); |
| |
| /** |
| * Constructor for doc flavor objects with the given MIME type |
| * and a print data representation class name of "java.io.Reader". |
| * |
| * @param mimeType the mime type string |
| * |
| * @throws NullPointerException if mimeType is <code>null</code>. |
| * @throws IllegalArgumentException if mimeType has the wrong syntax. |
| */ |
| public READER(String mimeType) |
| { |
| super(mimeType, "java.io.Reader"); |
| } |
| } |
| |
| /** |
| * Predefined static <code>DocFlavor</code> objects for document |
| * types which use service formatted print data. |
| * <p>All the defined doc flavors have a MIME type of |
| * "application/x-java-jvm-local-objectref".</p> |
| * |
| * @author Michael Koch (konqueror@gmx.de) |
| */ |
| public static class SERVICE_FORMATTED |
| extends DocFlavor |
| { |
| private static final long serialVersionUID = 6181337766266637256L; |
| |
| /** |
| * Service formatted doc flavor with a representation class of |
| * "java.awt.print.Pageable". |
| */ |
| public static final DocFlavor.SERVICE_FORMATTED PAGEABLE = new SERVICE_FORMATTED("java.awt.print.Pageable"); |
| /** |
| * Service formatted doc flavor with a representation class of |
| * "java.awt.print.Printable". |
| */ |
| public static final DocFlavor.SERVICE_FORMATTED PRINTABLE = new SERVICE_FORMATTED("java.awt.print.Printable"); |
| /** |
| * Service formatted doc flavor with a representation class of |
| * "java.awt.image.renderable.RenderableImage". |
| */ |
| public static final DocFlavor.SERVICE_FORMATTED RENDERABLE_IMAGE = new SERVICE_FORMATTED("java.awt.image.renderable.RenderableImage"); |
| |
| /** |
| * Constructor for doc flavor objects with a MIME type of |
| * "application/x-java-jvm-local-objectref" and the given |
| * print data representation classname. |
| * |
| * @param className the representation classname |
| * |
| * @throws NullPointerException if className is <code>null</code>. |
| */ |
| public SERVICE_FORMATTED(String className) |
| { |
| super("application/x-java-jvm-local-objectref", className); |
| } |
| } |
| |
| /** |
| * Predefined static <code>DocFlavor</code> objects for document |
| * types which use a String for the print data representation. |
| * <p>All the defined doc flavors have a print data representation |
| * classname of "java.lang.String".</p> |
| * |
| * @author Michael Koch (konqueror@gmx.de) |
| */ |
| public static class STRING |
| extends DocFlavor |
| { |
| private static final long serialVersionUID = 4414407504887034035L; |
| |
| /** |
| * String doc flavor with a MIME Type of "text/html; charset=utf-16". |
| */ |
| public static final DocFlavor.STRING TEXT_HTML = new STRING("text/html; charset=utf-16"); |
| /** |
| * String doc flavor with a MIME Type of "text/plain; charset=utf-16". |
| */ |
| public static final DocFlavor.STRING TEXT_PLAIN = new STRING("text/plain; charset=utf-16"); |
| |
| /** |
| * Constructor for doc flavor objects with the given MIME type |
| * and a print data representation class name of "java.lang.String". |
| * |
| * @param mimeType the mime type string |
| * |
| * @throws NullPointerException if mimeType is <code>null</code>. |
| * @throws IllegalArgumentException if mimeType has the wrong syntax. |
| */ |
| public STRING(String mimeType) |
| { |
| super(mimeType, "java.lang.String"); |
| } |
| } |
| |
| /** |
| * Predefined static <code>DocFlavor</code> objects for document |
| * types which have an URL where to retrieve the print data. |
| * <p>All the defined doc flavors have a print data representation |
| * classname of "java.net.URL".</p> |
| * |
| * @author Michael Koch (konqueror@gmx.de) |
| */ |
| public static class URL |
| extends DocFlavor |
| { |
| private static final long serialVersionUID = 2936725788144902062L; |
| |
| /** |
| * URL doc flavor with a MIME Type of "application/octet-stream". |
| */ |
| public static final DocFlavor.URL AUTOSENSE = new URL("application/octet-stream"); |
| /** |
| * URL doc flavor with a MIME Type of "image/gif". |
| */ |
| public static final DocFlavor.URL GIF = new URL("image/gif"); |
| /** |
| * URL doc flavor with a MIME Type of "image/jpeg". |
| */ |
| public static final DocFlavor.URL JPEG = new URL("image/jpeg"); |
| /** |
| * URL doc flavor with a MIME Type of "application/vnd.hp-PCL". |
| */ |
| public static final DocFlavor.URL PCL = new URL("application/vnd.hp-PCL"); |
| /** |
| * URL doc flavor with a MIME Type of "application/pdf". |
| */ |
| public static final DocFlavor.URL PDF = new URL("application/pdf"); |
| /** |
| * URL doc flavor with a MIME Type of "image/png". |
| */ |
| public static final DocFlavor.URL PNG = new URL("image/png"); |
| /** |
| * URL doc flavor with a MIME Type of "application/postscript". |
| */ |
| public static final DocFlavor.URL POSTSCRIPT = new URL("application/postscript"); |
| /** |
| * URL doc flavor with a MIME Type of "text/html" in the host encoding. |
| */ |
| public static final DocFlavor.URL TEXT_HTML_HOST = new URL("text/html; charset=" + hostEncoding); |
| /** |
| * URL doc flavor with a MIME Type of "text/html; charset=us-ascii". |
| */ |
| public static final DocFlavor.URL TEXT_HTML_US_ASCII = new URL("text/html; charset=us-ascii"); |
| /** |
| * URL doc flavor with a MIME Type of "text/html; charset=utf-16". |
| */ |
| public static final DocFlavor.URL TEXT_HTML_UTF_16 = new URL("text/html; charset=utf-16"); |
| /** |
| * URL doc flavor with a MIME Type of "text/html; charset=utf-16be". |
| */ |
| public static final DocFlavor.URL TEXT_HTML_UTF_16BE = new URL("text/html; charset=utf-16be"); |
| /** |
| * URL doc flavor with a MIME Type of "text/html; charset=utf-16le". |
| */ |
| public static final DocFlavor.URL TEXT_HTML_UTF_16LE = new URL("text/html; charset=utf-16le"); |
| /** |
| * URL doc flavor with a MIME Type of "text/html; charset=utf-8". |
| */ |
| public static final DocFlavor.URL TEXT_HTML_UTF_8 = new URL("text/html; charset=utf-8"); |
| /** |
| * URL doc flavor with a MIME Type of "text/plain" in the host encoding. |
| */ |
| public static final DocFlavor.URL TEXT_PLAIN_HOST = new URL("text/plain; charset=" + hostEncoding); |
| /** |
| * URL doc flavor with a MIME Type of "text/plain; charset=us-ascii". |
| */ |
| public static final DocFlavor.URL TEXT_PLAIN_US_ASCII = new URL("text/plain; charset=us-ascii"); |
| /** |
| * URL doc flavor with a MIME Type of "text/plain; charset=utf-16". |
| */ |
| public static final DocFlavor.URL TEXT_PLAIN_UTF_16 = new URL("text/plain; charset=utf-16"); |
| /** |
| * URL doc flavor with a MIME Type of "text/plain; charset=utf-16be". |
| */ |
| public static final DocFlavor.URL TEXT_PLAIN_UTF_16BE = new URL("text/plain; charset=utf-16be"); |
| /** |
| * URL doc flavor with a MIME Type of "text/plain; charset=utf-16le". |
| */ |
| public static final DocFlavor.URL TEXT_PLAIN_UTF_16LE = new URL("text/plain; charset=utf-16le"); |
| /** |
| * URL doc flavor with a MIME Type of "text/plain; charset=utf-8". |
| */ |
| public static final DocFlavor.URL TEXT_PLAIN_UTF_8 = new URL("text/plain; charset=utf-8"); |
| |
| /** |
| * Constructor for doc flavor objects with the given MIME type |
| * and a print data representation class name of "java.net.URL". |
| * |
| * @param mimeType the mime type string |
| * |
| * @throws NullPointerException if mimeType is <code>null</code>. |
| * @throws IllegalArgumentException if mimeType has the wrong syntax. |
| */ |
| public URL(String mimeType) |
| { |
| super(mimeType, "java.net.URL"); |
| } |
| } |
| |
| private static final long serialVersionUID = -4512080796965449721L; |
| |
| /** |
| * The string representing the host encoding. This is the encoding |
| * used in the predefined HOST doc flavors |
| * (e.g. {@link BYTE_ARRAY#TEXT_HTML_HOST}). |
| */ |
| public static final String hostEncoding = Charset.defaultCharset().name(); |
| |
| private transient String mediaSubtype; |
| private transient String mediaType; |
| private transient TreeMap params; |
| |
| // name as defined in Serialized Form JDK 1.4 |
| private String myClassName; |
| |
| /** |
| * Constructs a <code>DocFlavor</code> object with the given MIME type and |
| * representation class name. |
| * |
| * @param mimeType the MIME type string. |
| * @param className the fully-qualified name of the representation class. |
| * |
| * @throws NullPointerException if mimeType or className are <code>null</code>. |
| * @throws IllegalArgumentException if given mimeType has syntax errors. |
| */ |
| public DocFlavor(String mimeType, String className) |
| { |
| if (mimeType == null || className == null) |
| throw new NullPointerException(); |
| |
| params = new TreeMap(); |
| parseMimeType(mimeType); |
| |
| myClassName = className; |
| } |
| |
| /** |
| * Parses the given string as MIME type. |
| * The mediatype, mediasubtype and all parameter/value |
| * combinations are extracted, comments are dropped. |
| * |
| * @param mimeType the string to parse |
| * @throws IllegalArgumentException if not conformant. |
| */ |
| private void parseMimeType(String mimeType) |
| { |
| int MEDIA = 1; |
| int MEDIASUB = 2; |
| int PARAM_NAME = 3; |
| int PARAM_VALUE = 4; |
| int COMMENT_START = 5; |
| |
| int state = 0; |
| int lastState = 0; // keeps track of state before comment |
| int tok; |
| |
| try |
| { |
| String paramName = null; |
| StreamTokenizer in = new StreamTokenizer(new StringReader(mimeType)); |
| in.resetSyntax(); |
| // Allowed characters are anything except: |
| // SPACE, CTLs (= Unicode characters U+0000 - U+001F and U+007F) |
| // and tspecials ( ) < > @ , ; : \ " / [ ] ? = |
| in.whitespaceChars(0x00, 0x20); |
| in.whitespaceChars(0x7F, 0x7F); |
| in.wordChars('A', 'Z'); |
| in.wordChars('a', 'z'); |
| in.wordChars('0', '9'); |
| in.wordChars(0xA0, 0xFF); |
| in.wordChars(0x21, 0x21); |
| in.wordChars(0x23, 0x27); |
| in.wordChars(0x2A, 0x2B); |
| in.wordChars(0x2D, 0x2E); |
| in.wordChars(0x5E, 0x60); |
| in.wordChars(0x7B, 0x7E); |
| in.quoteChar('"'); |
| |
| while ((tok = in.nextToken()) != StreamTokenizer.TT_EOF) |
| { |
| switch (tok) |
| { |
| case StreamTokenizer.TT_WORD: |
| if (state == 0) |
| { |
| mediaType = in.sval.toLowerCase(); |
| state = MEDIA; |
| break; |
| } |
| if (state == MEDIA) |
| { |
| mediaSubtype = in.sval.toLowerCase(); |
| state = MEDIASUB; |
| break; |
| } |
| // begin of parameters is either after mediasub or a parameter value |
| if (state == MEDIASUB || state == PARAM_VALUE) |
| { |
| paramName = in.sval.toLowerCase(); |
| state = PARAM_NAME; |
| break; |
| } |
| // a parameter always needs to follow a value |
| if (state == PARAM_NAME) |
| { |
| String paramValue = in.sval; |
| // if a charset param the value needs to be stored lowercase |
| if (paramName.equals("charset")) |
| paramValue = paramValue.toLowerCase(); |
| |
| state = PARAM_VALUE; |
| params.put(paramName, paramValue); |
| break; |
| } |
| if (state == COMMENT_START) |
| { |
| // ignore; |
| break; |
| } |
| break; |
| case '/': |
| // may only occur after the mediatype |
| if (state != MEDIA) |
| throw new IllegalArgumentException(); |
| |
| break; |
| case '=': |
| // may only occur after a parameter |
| if (state != PARAM_NAME) |
| throw new IllegalArgumentException(); |
| |
| break; |
| case ';': |
| // differentiates mime type and parameters/value combinations |
| if (state != MEDIASUB && state != PARAM_VALUE) |
| throw new IllegalArgumentException(); |
| |
| break; |
| case '(': // begin comment |
| lastState = state; |
| state = COMMENT_START; |
| break; |
| case ')': // end comment |
| state = lastState; |
| break; |
| // a parameter always needs to follow a value / or quoted value |
| case '"': |
| if (state == PARAM_NAME) |
| { |
| String paramValue = in.sval; |
| // if a charset param the value needs to be stored lowercase |
| if (paramName.equals("charset")) |
| paramValue = paramValue.toLowerCase(); |
| |
| state = PARAM_VALUE; |
| params.put(paramName, paramValue); |
| break; |
| } |
| |
| // only values may be quoted |
| throw new IllegalArgumentException(); |
| default: |
| // if any other char is observed its not allowed |
| throw new IllegalArgumentException(); |
| } |
| } |
| } |
| catch (IOException e) |
| { |
| // should not happen as mimetype str cannot be null |
| throw new InternalError("IOException during parsing String " + mimeType); |
| } |
| } |
| |
| /** |
| * Checks if this doc flavor object is equal to the given object. |
| * <p> |
| * Two doc flavor objects are considered equal if the provided object is not |
| * <code>null</code> and an instance of <code>DocFlavor</code>. The MIME |
| * types has to be equal in their media type, media subtype, their |
| * paramter/value combinations and the representation classname. |
| * </p> |
| * |
| * @param obj the object to test. |
| * @return <code>true</code> if equal, <code>false</code> otherwise. |
| */ |
| public boolean equals(Object obj) |
| { |
| if (! (obj instanceof DocFlavor)) |
| return false; |
| |
| DocFlavor tmp = (DocFlavor) obj; |
| |
| return (getMimeType().equals(tmp.getMimeType()) |
| && getRepresentationClassName().equals(tmp.getRepresentationClassName())); |
| } |
| |
| /** |
| * Returns the media subtype of this flavor object. |
| * A mimetype of "text/html; charset=us-ascii" will |
| * return "html" as the media subtype. |
| * |
| * @return The media subtype. |
| */ |
| public String getMediaSubtype() |
| { |
| return mediaSubtype; |
| } |
| |
| /** |
| * Returns the media type of this flavor object. |
| * A mimetype of "text/html; charset=us-ascii" will |
| * return "text" as the media type. |
| * |
| * @return The media type. |
| */ |
| public String getMediaType() |
| { |
| return mediaType; |
| } |
| |
| /** |
| * Returns the mime type of this flavor object. |
| * The mimetype will have every parameter value |
| * enclosed in quotes. |
| * |
| * @return The mime type. |
| */ |
| public String getMimeType() |
| { |
| String mimeType = getMediaType() + "/" + getMediaSubtype(); |
| Iterator it = params.entrySet().iterator(); |
| |
| while (it.hasNext()) |
| { |
| Map.Entry entry = (Map.Entry) it.next(); |
| mimeType += "; " + entry.getKey() + "=\"" + entry.getValue() + "\""; |
| } |
| |
| return mimeType; |
| } |
| |
| /** |
| * Returns the value for an optional parameter of the mime type of this |
| * flavor object. |
| * |
| * @param paramName the name of the parameter |
| * @return The value for the parameter, or <code>null</code> if none bound. |
| * @throws NullPointerException if paramName is <code>null</code>. |
| */ |
| public String getParameter(String paramName) |
| { |
| if (paramName == null) |
| throw new NullPointerException(); |
| |
| return (String) params.get(paramName.toLowerCase()); |
| } |
| |
| /** |
| * Returns the name of the representation class of this flavor object. |
| * |
| * @return The representation classname. |
| */ |
| public String getRepresentationClassName() |
| { |
| return myClassName; |
| } |
| |
| /** |
| * Returns a hash code for this doc flavor object. |
| * |
| * @return The hashcode. |
| */ |
| public int hashCode() |
| { |
| return ((mediaType.hashCode() |
| * mediaSubtype.hashCode() |
| * myClassName.hashCode()) ^ params.hashCode()); |
| } |
| |
| /** |
| * Returns a string representation of this doc flavor object. |
| * The returned string is of the form |
| * getMimeType() + "; class=\"" + getRepresentationClassName() + "\""; |
| * |
| * @return The constructed string representation. |
| */ |
| public String toString() |
| { |
| return getMimeType() + "; class=\"" + getRepresentationClassName() + "\""; |
| } |
| |
| // needs special treatment for serialization |
| private void readObject(ObjectInputStream stream) |
| throws IOException, ClassNotFoundException |
| { |
| params = new TreeMap(); |
| myClassName = (String) stream.readObject(); |
| parseMimeType((String) stream.readObject()); |
| } |
| |
| private void writeObject(java.io.ObjectOutputStream stream) |
| throws IOException |
| { |
| stream.writeObject(myClassName); |
| stream.writeObject(getMimeType()); |
| } |
| } |
