mirror of git://gcc.gnu.org/git/gcc.git
916 lines
34 KiB
Java
916 lines
34 KiB
Java
/* 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());
|
|
}
|
|
}
|