You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1434 lines
54 KiB
1434 lines
54 KiB
/*
|
|
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package javax.print;
|
|
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.io.Serializable;
|
|
|
|
|
|
/**
|
|
* Class <code>DocFlavor</code> encapsulates an object that specifies the
|
|
* format in which print data is supplied to a {@link DocPrintJob}.
|
|
* "Doc" is a short, easy-to-pronounce term that means "a piece of print data."
|
|
* The print data format, or "doc flavor", consists of two things:
|
|
* <UL>
|
|
* <LI>
|
|
* <B>MIME type.</B> This is a Multipurpose Internet Mail Extensions (MIME)
|
|
* media type (as defined in <A HREF="http://www.ietf.org/rfc/rfc2045.txt">RFC
|
|
* 2045</A> and <A HREF="http://www.ietf.org/rfc/rfc2046.txt">RFC 2046</A>)
|
|
* that specifies how the print data is to be interpreted.
|
|
* The charset of text data should be the IANA MIME-preferred name, or its
|
|
* canonical name if no preferred name is specified. Additionally a few
|
|
* historical names supported by earlier versions of the Java platform may
|
|
* be recognized.
|
|
* See <a href="../../java/lang/package-summary.html#charenc">
|
|
* character encodings</a> for more information on the character encodings
|
|
* supported on the Java platform.
|
|
* <P>
|
|
* <LI>
|
|
* <B>Representation class name.</B> This specifies the fully-qualified name of
|
|
* the class of the object from which the actual print data comes, as returned
|
|
* by the {@link java.lang.Class#getName() Class.getName()} method.
|
|
* (Thus the class name for <CODE>byte[]</CODE> is <CODE>"[B"</CODE>, for
|
|
* <CODE>char[]</CODE> it is <CODE>"[C"</CODE>.)
|
|
* </UL>
|
|
* <P>
|
|
* A <code>DocPrintJob</code> obtains its print data by means of interface
|
|
* {@link Doc Doc}. A <code>Doc</code> object lets the <code>DocPrintJob</code>
|
|
* determine the doc flavor the client can supply. A <code>Doc</code> object
|
|
* also lets the <code>DocPrintJob</code> obtain an instance of the doc flavor's
|
|
* representation class, from which the <code>DocPrintJob</code> then obtains
|
|
* the actual print data.
|
|
* <P>
|
|
* <HR>
|
|
* <H3>Client Formatted Print Data</H3>
|
|
* There are two broad categories of print data, client formatted print data
|
|
* and service formatted print data.
|
|
* <P>
|
|
* For <B>client formatted print data</B>, the client determines or knows the
|
|
* print data format.
|
|
* For example the client may have a JPEG encoded image, a URL for
|
|
* HTML code, or a disk file containing plain text in some encoding,
|
|
* possibly obtained from an external source, and
|
|
* requires a way to describe the data format to the print service.
|
|
* <p>
|
|
* The doc flavor's representation class is a conduit for the JPS
|
|
* <code>DocPrintJob</code> to obtain a sequence of characters or
|
|
* bytes from the client. The
|
|
* doc flavor's MIME type is one of the standard media types telling how to
|
|
* interpret the sequence of characters or bytes. For a list of standard media
|
|
* types, see the Internet Assigned Numbers Authority's (IANA's) <A
|
|
* HREF="http://www.iana.org/assignments/media-types/">Media Types
|
|
* Directory</A>. Interface {@link Doc Doc} provides two utility operations,
|
|
* {@link Doc#getReaderForText() getReaderForText} and
|
|
* {@link Doc#getStreamForBytes() getStreamForBytes()}, to help a
|
|
* <code>Doc</code> object's client extract client formatted print data.
|
|
* <P>
|
|
* For client formatted print data, the print data representation class is
|
|
* typically one of the following (although other representation classes are
|
|
* permitted):
|
|
* <UL>
|
|
* <LI>
|
|
* Character array (<CODE>char[]</CODE>) -- The print data consists of the
|
|
* Unicode characters in the array.
|
|
* <P>
|
|
* <LI>
|
|
* <code>String</code> --
|
|
* The print data consists of the Unicode characters in the string.
|
|
* <P>
|
|
* <LI>
|
|
* Character stream ({@link java.io.Reader java.io.Reader})
|
|
* -- The print data consists of the Unicode characters read from the stream
|
|
* up to the end-of-stream.
|
|
* <P>
|
|
* <LI>
|
|
* Byte array (<CODE>byte[]</CODE>) -- The print data consists of the bytes in
|
|
* the array. The bytes are encoded in the character set specified by the doc
|
|
* flavor's MIME type. If the MIME type does not specify a character set, the
|
|
* default character set is US-ASCII.
|
|
* <P>
|
|
* <LI>
|
|
* Byte stream ({@link java.io.InputStream java.io.InputStream}) --
|
|
* The print data consists of the bytes read from the stream up to the
|
|
* end-of-stream. The bytes are encoded in the character set specified by the
|
|
* doc flavor's MIME type. If the MIME type does not specify a character set,
|
|
* the default character set is US-ASCII.
|
|
|
|
* <LI>
|
|
* Uniform Resource Locator ({@link java.net.URL URL})
|
|
* -- The print data consists of the bytes read from the URL location.
|
|
* The bytes are encoded in the character set specified by the doc flavor's
|
|
* MIME type. If the MIME type does not specify a character set, the default
|
|
* character set is US-ASCII.
|
|
* <P>
|
|
* When the representation class is a URL, the print service itself accesses
|
|
* and downloads the document directly from its URL address, without involving
|
|
* the client. The service may be some form of network print service which
|
|
* is executing in a different environment.
|
|
* This means you should not use a URL print data flavor to print a
|
|
* document at a restricted URL that the client can see but the printer cannot
|
|
* see. This also means you should not use a URL print data flavor to print a
|
|
* document stored in a local file that is not available at a URL
|
|
* accessible independently of the client.
|
|
* For example, a file that is not served up by an HTTP server or FTP server.
|
|
* To print such documents, let the client open an input stream on the URL
|
|
* or file and use an input stream data flavor.
|
|
* </UL>
|
|
* <p>
|
|
* <HR>
|
|
* <h3>Default and Platform Encodings</h3>
|
|
* <P>
|
|
* For byte print data where the doc flavor's MIME type does not include a
|
|
* <CODE>charset</CODE> parameter, the Java Print Service instance assumes the
|
|
* US-ASCII character set by default. This is in accordance with
|
|
* <A HREF="http://www.ietf.org/rfc/rfc2046.txt">RFC 2046</A>, which says the
|
|
* default character set is US-ASCII. Note that US-ASCII is a subset of
|
|
* UTF-8, so in the future this may be widened if a future RFC endorses
|
|
* UTF-8 as the default in a compatible manner.
|
|
* <p>
|
|
* Also note that this is different than the behaviour of the Java runtime
|
|
* when interpreting a stream of bytes as text data. That assumes the
|
|
* default encoding for the user's locale. Thus, when spooling a file in local
|
|
* encoding to a Java Print Service it is important to correctly specify
|
|
* the encoding. Developers working in the English locales should
|
|
* be particularly conscious of this, as their platform encoding corresponds
|
|
* to the default mime charset. By this coincidence that particular
|
|
* case may work without specifying the encoding of platform data.
|
|
* <p>
|
|
* Every instance of the Java virtual machine has a default character encoding
|
|
* determined during virtual-machine startup and typically depends upon the
|
|
* locale and charset being used by the underlying operating system.
|
|
* In a distributed environment there is no guarantee that two VM share
|
|
* the same default encoding. Thus clients which want to stream platform
|
|
* encoded text data from the host platform to a Java Print Service instance
|
|
* must explicitly declare the charset and not rely on defaults.
|
|
* <p>
|
|
* The preferred form is the official IANA primary name for an encoding.
|
|
* Applications which stream text data should always specify the charset
|
|
* in the mime type, which necessitates obtaining the encoding of the host
|
|
* platform for data (eg files) stored in that platform's encoding.
|
|
* A CharSet which corresponds to this and is suitable for use in a
|
|
* mime-type for a DocFlavor can be obtained
|
|
* from {@link DocFlavor#hostEncoding DocFlavor.hostEncoding}
|
|
* This may not always be the primary IANA name but is guaranteed to be
|
|
* understood by this VM.
|
|
* For common flavors, the pre-defined *HOST DocFlavors may be used.
|
|
* <p>
|
|
* <p>
|
|
* See <a href="../../java/lang/package-summary.html#charenc">
|
|
* character encodings</a> for more information on the character encodings
|
|
* supported on the Java platform.
|
|
* <p>
|
|
* <HR>
|
|
* <h3>Recommended DocFlavors</h3>
|
|
* <P>
|
|
* The Java Print Service API does not define any mandatorily supported
|
|
* DocFlavors.
|
|
* However, here are some examples of MIME types that a Java Print Service
|
|
* instance might support for client formatted print data.
|
|
* Nested classes inside class DocFlavor declare predefined static
|
|
* constant DocFlavor objects for these example doc flavors; class DocFlavor's
|
|
* constructor can be used to create an arbitrary doc flavor.
|
|
* <UL>
|
|
* <LI>Preformatted text
|
|
* <P>
|
|
* <TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 SUMMARY="MIME-Types and their descriptions">
|
|
* <TR>
|
|
* <TH>MIME-Type</TH><TH>Description</TH>
|
|
* </TR>
|
|
* <TR>
|
|
* <TD><CODE>"text/plain"</CODE></TD>
|
|
* <TD>Plain text in the default character set (US-ASCII)</TD>
|
|
* </TR>
|
|
* <TR>
|
|
* <TD><CODE>"text/plain; charset=<I>xxx</I>"</CODE></TD>
|
|
* <TD>Plain text in character set <I>xxx</I></TD>
|
|
* </TR>
|
|
* <TR>
|
|
* <TD><CODE>"text/html"</CODE></TD>
|
|
* <TD>HyperText Markup Language in the default character set (US-ASCII)</TD>
|
|
* </TR>
|
|
* <TR>
|
|
* <TD><CODE>"text/html; charset=<I>xxx</I>"</CODE></TD>
|
|
* <TD>HyperText Markup Language in character set <I>xxx</I></TD>
|
|
* </TR>
|
|
* </TABLE>
|
|
* <P>
|
|
* In general, preformatted text print data is provided either in a character
|
|
* oriented representation class (character array, String, Reader) or in a
|
|
* byte oriented representation class (byte array, InputStream, URL).
|
|
* <P>
|
|
* <LI>Preformatted page description language (PDL) documents
|
|
*<P>
|
|
* <TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 SUMMARY="MIME-Types and their descriptions">
|
|
* <TR>
|
|
* <TH>MIME-Type</TH><TH>Description</TH>
|
|
* </TR>
|
|
*<TR>
|
|
* <TD><CODE>"application/pdf"</CODE></TD>
|
|
* <TD>Portable Document Format document</TD>
|
|
* </TR>
|
|
* <TR>
|
|
* <TD><CODE>"application/postscript"</CODE></TD>
|
|
* <TD>PostScript document</TD>
|
|
* </TR>
|
|
* <TR>
|
|
* <TD><CODE>"application/vnd.hp-PCL"</CODE></TD>
|
|
* <TD>Printer Control Language document</TD>
|
|
* </TR>
|
|
* </TABLE>
|
|
* <P>
|
|
* In general, preformatted PDL print data is provided in a byte oriented
|
|
* representation class (byte array, InputStream, URL).
|
|
* <P>
|
|
* <LI>Preformatted images
|
|
*<P>
|
|
* <TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 SUMMARY="MIME-Types and their descriptions">
|
|
* <TR>
|
|
* <TH>MIME-Type</TH><TH>Description</TH>
|
|
* </TR>
|
|
*
|
|
* <TR>
|
|
* <TD><CODE>"image/gif"</CODE></TD>
|
|
* <TD>Graphics Interchange Format image</TD>
|
|
* </TR>
|
|
* <TR>
|
|
* <TD><CODE>"image/jpeg"</CODE></TD>
|
|
* <TD>Joint Photographic Experts Group image</TD>
|
|
* </TR>
|
|
* <TR>
|
|
* <TD><CODE>"image/png"</CODE></TD>
|
|
* <TD>Portable Network Graphics image</TD>
|
|
* </TR>
|
|
* </TABLE>
|
|
* <P>
|
|
* In general, preformatted image print data is provided in a byte oriented
|
|
* representation class (byte array, InputStream, URL).
|
|
* <P>
|
|
* <LI>Preformatted autosense print data
|
|
* <P>
|
|
* <TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 SUMMARY="MIME-Types and their descriptions">
|
|
* <TR>
|
|
* <TH>MIME-Type</TH><TH>Description</TH>
|
|
* </TR>
|
|
*
|
|
* <TR>
|
|
* <TD><CODE>"application/octet-stream"</CODE></TD>
|
|
* <TD>The print data format is unspecified (just an octet stream)</TD>
|
|
* </TABLE>
|
|
* <P>
|
|
* The printer decides how to interpret the print data; the way this
|
|
* "autosensing" works is implementation dependent. In general, preformatted
|
|
* autosense print data is provided in a byte oriented representation class
|
|
* (byte array, InputStream, URL).
|
|
* </UL>
|
|
* <P>
|
|
* <HR>
|
|
* <H3>Service Formatted Print Data</H3>
|
|
* <P>
|
|
* For <B>service formatted print data</B>, the Java Print Service instance
|
|
* determines the print data format. The doc flavor's representation class
|
|
* denotes an interface whose methods the <code>DocPrintJob</code> invokes to
|
|
* determine the content to be printed -- such as a renderable image
|
|
* interface or a Java printable interface.
|
|
* The doc flavor's MIME type is the special value
|
|
* <CODE>"application/x-java-jvm-local-objectref"</CODE> indicating the client
|
|
* will supply a reference to a Java object that implements the interface
|
|
* named as the representation class.
|
|
* This MIME type is just a placeholder; what's
|
|
* important is the print data representation class.
|
|
* <P>
|
|
* For service formatted print data, the print data representation class is
|
|
* typically one of the following (although other representation classes are
|
|
* permitted). Nested classes inside class DocFlavor declare predefined static
|
|
* constant DocFlavor objects for these example doc flavors; class DocFlavor's
|
|
* constructor can be used to create an arbitrary doc flavor.
|
|
* <UL>
|
|
* <LI>
|
|
* Renderable image object -- The client supplies an object that implements
|
|
* interface
|
|
* {@link java.awt.image.renderable.RenderableImage RenderableImage}. The
|
|
* printer calls methods
|
|
* in that interface to obtain the image to be printed.
|
|
* <P>
|
|
* <LI>
|
|
* Printable object -- The client supplies an object that implements interface
|
|
* {@link java.awt.print.Printable Printable}.
|
|
* The printer calls methods in that interface to obtain the pages to be
|
|
* printed, one by one.
|
|
* For each page, the printer supplies a graphics context, and whatever the
|
|
* client draws in that graphics context gets printed.
|
|
* <P>
|
|
* <LI>
|
|
* Pageable object -- The client supplies an object that implements interface
|
|
* {@link java.awt.print.Pageable Pageable}. The printer calls
|
|
* methods in that interface to obtain the pages to be printed, one by one.
|
|
* For each page, the printer supplies a graphics context, and whatever
|
|
* the client draws in that graphics context gets printed.
|
|
* </UL>
|
|
* <P>
|
|
* <HR>
|
|
* <P>
|
|
* <HR>
|
|
* <H3>Pre-defined Doc Flavors</H3>
|
|
* A Java Print Service instance is not <B><I>required</I></B> to support the
|
|
* following print data formats and print data representation classes. In
|
|
* fact, a developer using this class should <b>never</b> assume that a
|
|
* particular print service supports the document types corresponding to
|
|
* these pre-defined doc flavors. Always query the print service
|
|
* to determine what doc flavors it supports. However,
|
|
* developers who have print services that support these doc flavors are
|
|
* encouraged to refer to the predefined singleton instances created here.
|
|
* <UL>
|
|
* <LI>
|
|
* Plain text print data provided through a byte stream. Specifically, the
|
|
* following doc flavors are recommended to be supported:
|
|
* <BR>·
|
|
* <CODE>("text/plain", "java.io.InputStream")</CODE>
|
|
* <BR>·
|
|
* <CODE>("text/plain; charset=us-ascii", "java.io.InputStream")</CODE>
|
|
* <BR>·
|
|
* <CODE>("text/plain; charset=utf-8", "java.io.InputStream")</CODE>
|
|
* <P>
|
|
* <LI>
|
|
* Renderable image objects. Specifically, the following doc flavor is
|
|
* recommended to be supported:
|
|
* <BR>·
|
|
* <CODE>("application/x-java-jvm-local-objectref", "java.awt.image.renderable.RenderableImage")</CODE>
|
|
* </UL>
|
|
* <P>
|
|
* A Java Print Service instance is allowed to support any other doc flavors
|
|
* (or none) in addition to the above mandatory ones, at the implementation's
|
|
* choice.
|
|
* <P>
|
|
* Support for the above doc flavors is desirable so a printing client can rely
|
|
* on being able to print on any JPS printer, regardless of which doc flavors
|
|
* the printer supports. If the printer doesn't support the client's preferred
|
|
* doc flavor, the client can at least print plain text, or the client can
|
|
* convert its data to a renderable image and print the image.
|
|
* <P>
|
|
* Furthermore, every Java Print Service instance must fulfill these
|
|
* requirements for processing plain text print data:
|
|
* <UL>
|
|
* <LI>
|
|
* The character pair carriage return-line feed (CR-LF) means
|
|
* "go to column 1 of the next line."
|
|
* <LI>
|
|
* A carriage return (CR) character standing by itself means
|
|
* "go to column 1 of the next line."
|
|
* <LI>
|
|
* A line feed (LF) character standing by itself means
|
|
* "go to column 1 of the next line."
|
|
* <LI>
|
|
* </UL>
|
|
* <P>
|
|
* The client must itself perform all plain text print data formatting not
|
|
* addressed by the above requirements.
|
|
* <P>
|
|
* <H3>Design Rationale</H3>
|
|
* <P>
|
|
* Class DocFlavor in package javax.print.data is similar to class
|
|
* {@link java.awt.datatransfer.DataFlavor DataFlavor}. Class
|
|
* <code>DataFlavor</code>
|
|
* is not used in the Java Print Service (JPS) API
|
|
* for three reasons which are all rooted in allowing the JPS API to be
|
|
* shared by other print services APIs which may need to run on Java profiles
|
|
* which do not include all of the Java Platform, Standard Edition.
|
|
* <OL TYPE=1>
|
|
* <LI>
|
|
* The JPS API is designed to be used in Java profiles which do not support
|
|
* AWT.
|
|
* <P>
|
|
* <LI>
|
|
* The implementation of class <code>java.awt.datatransfer.DataFlavor</code>
|
|
* does not guarantee that equivalent data flavors will have the same
|
|
* serialized representation. DocFlavor does, and can be used in services
|
|
* which need this.
|
|
* <P>
|
|
* <LI>
|
|
* The implementation of class <code>java.awt.datatransfer.DataFlavor</code>
|
|
* includes a human presentable name as part of the serialized representation.
|
|
* This is not appropriate as part of a service matching constraint.
|
|
* </OL>
|
|
* <P>
|
|
* Class DocFlavor's serialized representation uses the following
|
|
* canonical form of a MIME type string. Thus, two doc flavors with MIME types
|
|
* that are not identical but that are equivalent (that have the same
|
|
* canonical form) may be considered equal.
|
|
* <UL>
|
|
* <LI> The media type, media subtype, and parameters are retained, but all
|
|
* comments and whitespace characters are discarded.
|
|
* <LI> The media type, media subtype, and parameter names are converted to
|
|
* lowercase.
|
|
* <LI> The parameter values retain their original case, except a charset
|
|
* parameter value for a text media type is converted to lowercase.
|
|
* <LI> Quote characters surrounding parameter values are removed.
|
|
* <LI> Quoting backslash characters inside parameter values are removed.
|
|
* <LI> The parameters are arranged in ascending order of parameter name.
|
|
* </UL>
|
|
* <P>
|
|
* Class DocFlavor's serialized representation also contains the
|
|
* fully-qualified class <I>name</I> of the representation class
|
|
* (a String object), rather than the representation class itself
|
|
* (a Class object). This allows a client to examine the doc flavors a
|
|
* Java Print Service instance supports without having
|
|
* to load the representation classes, which may be problematic for
|
|
* limited-resource clients.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public class DocFlavor implements Serializable, Cloneable {
|
|
|
|
private static final long serialVersionUID = -4512080796965449721L;
|
|
|
|
/**
|
|
* A String representing the host operating system encoding.
|
|
* This will follow the conventions documented in
|
|
* <a href="http://www.ietf.org/rfc/rfc2278.txt">
|
|
* <i>RFC 2278: IANA Charset Registration Procedures</i></a>
|
|
* except where historical names are returned for compatibility with
|
|
* previous versions of the Java platform.
|
|
* The value returned from method is valid only for the VM which
|
|
* returns it, for use in a DocFlavor.
|
|
* This is the charset for all the "HOST" pre-defined DocFlavors in
|
|
* the executing VM.
|
|
*/
|
|
public static final String hostEncoding;
|
|
|
|
static {
|
|
hostEncoding =
|
|
(String)java.security.AccessController.doPrivileged(
|
|
new sun.security.action.GetPropertyAction("file.encoding"));
|
|
}
|
|
|
|
/**
|
|
* MIME type.
|
|
*/
|
|
private transient MimeType myMimeType;
|
|
|
|
/**
|
|
* Representation class name.
|
|
* @serial
|
|
*/
|
|
private String myClassName;
|
|
|
|
/**
|
|
* String value for this doc flavor. Computed when needed and cached.
|
|
*/
|
|
private transient String myStringValue = null;
|
|
|
|
|
|
/**
|
|
* Constructs a new doc flavor object from the given MIME type and
|
|
* representation class name. The given MIME type is converted into
|
|
* canonical form and stored internally.
|
|
*
|
|
* @param mimeType MIME media type string.
|
|
* @param className Fully-qualified representation class name.
|
|
*
|
|
* @exception NullPointerException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null or
|
|
* <CODE>className</CODE> is null.
|
|
* @exception IllegalArgumentException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not
|
|
* obey the syntax for a MIME media type string.
|
|
*/
|
|
public DocFlavor(String mimeType, String className) {
|
|
if (className == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
myMimeType = new MimeType (mimeType);
|
|
myClassName = className;
|
|
}
|
|
|
|
/**
|
|
* Returns this doc flavor object's MIME type string based on the
|
|
* canonical form. Each parameter value is enclosed in quotes.
|
|
* @return the mime type
|
|
*/
|
|
public String getMimeType() {
|
|
return myMimeType.getMimeType();
|
|
}
|
|
|
|
/**
|
|
* Returns this doc flavor object's media type (from the MIME type).
|
|
* @return the media type
|
|
*/
|
|
public String getMediaType() {
|
|
return myMimeType.getMediaType();
|
|
}
|
|
|
|
/**
|
|
* Returns this doc flavor object's media subtype (from the MIME type).
|
|
* @return the media sub-type
|
|
*/
|
|
public String getMediaSubtype() {
|
|
return myMimeType.getMediaSubtype();
|
|
}
|
|
|
|
/**
|
|
* Returns a <code>String</code> representing a MIME
|
|
* parameter.
|
|
* Mime types may include parameters which are usually optional.
|
|
* The charset for text types is a commonly useful example.
|
|
* This convenience method will return the value of the specified
|
|
* parameter if one was specified in the mime type for this flavor.
|
|
* <p>
|
|
* @param paramName the name of the paramater. This name is internally
|
|
* converted to the canonical lower case format before performing
|
|
* the match.
|
|
* @return String representing a mime parameter, or
|
|
* null if that parameter is not in the mime type string.
|
|
* @exception NullPointerException if paramName is null.
|
|
*/
|
|
public String getParameter(String paramName) {
|
|
return
|
|
(String)myMimeType.getParameterMap().get(paramName.toLowerCase());
|
|
}
|
|
|
|
/**
|
|
* Returns the name of this doc flavor object's representation class.
|
|
* @return the name of the representation class.
|
|
*/
|
|
public String getRepresentationClassName() {
|
|
return myClassName;
|
|
}
|
|
|
|
/**
|
|
* Converts this <code>DocFlavor</code> to a string.
|
|
*
|
|
* @return MIME type string based on the canonical form. Each parameter
|
|
* value is enclosed in quotes.
|
|
* A "class=" parameter is appended to the
|
|
* MIME type string to indicate the representation class name.
|
|
*/
|
|
public String toString() {
|
|
return getStringValue();
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code for this doc flavor object.
|
|
*/
|
|
public int hashCode() {
|
|
return getStringValue().hashCode();
|
|
}
|
|
|
|
/**
|
|
* Determines if this doc flavor object is equal to the given object.
|
|
* The two are equal if the given object is not null, is an instance
|
|
* of <code>DocFlavor</code>, has a MIME type equivalent to this doc
|
|
* flavor object's MIME type (that is, the MIME types have the same media
|
|
* type, media subtype, and parameters), and has the same representation
|
|
* class name as this doc flavor object. Thus, if two doc flavor objects'
|
|
* MIME types are the same except for comments, they are considered equal.
|
|
* However, two doc flavor objects with MIME types of "text/plain" and
|
|
* "text/plain; charset=US-ASCII" are not considered equal, even though
|
|
* they represent the same media type (because the default character
|
|
* set for plain text is US-ASCII).
|
|
*
|
|
* @param obj Object to test.
|
|
*
|
|
* @return True if this doc flavor object equals <CODE>obj</CODE>, false
|
|
* otherwise.
|
|
*/
|
|
public boolean equals(Object obj) {
|
|
return
|
|
obj != null &&
|
|
obj instanceof DocFlavor &&
|
|
getStringValue().equals (((DocFlavor) obj).getStringValue());
|
|
}
|
|
|
|
/**
|
|
* Returns this doc flavor object's string value.
|
|
*/
|
|
private String getStringValue() {
|
|
if (myStringValue == null) {
|
|
myStringValue = myMimeType + "; class=\"" + myClassName + "\"";
|
|
}
|
|
return myStringValue;
|
|
}
|
|
|
|
/**
|
|
* Write the instance to a stream (ie serialize the object).
|
|
*/
|
|
private void writeObject(ObjectOutputStream s) throws IOException {
|
|
|
|
s.defaultWriteObject();
|
|
s.writeObject(myMimeType.getMimeType());
|
|
}
|
|
|
|
/**
|
|
* Reconstitute an instance from a stream (that is, deserialize it).
|
|
*
|
|
* @serialData
|
|
* The serialised form of a DocFlavor is the String naming the
|
|
* representation class followed by the String representing the canonical
|
|
* form of the mime type.
|
|
*/
|
|
private void readObject(ObjectInputStream s)
|
|
throws ClassNotFoundException, IOException {
|
|
|
|
s.defaultReadObject();
|
|
myMimeType = new MimeType((String)s.readObject());
|
|
}
|
|
|
|
/**
|
|
* Class DocFlavor.BYTE_ARRAY provides predefined static constant
|
|
* DocFlavor objects for example doc flavors using a byte array
|
|
* (<CODE>byte[]</CODE>) as the print data representation class.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public static class BYTE_ARRAY extends DocFlavor {
|
|
|
|
private static final long serialVersionUID = -9065578006593857475L;
|
|
|
|
/**
|
|
* Constructs a new doc flavor with the given MIME type and a print
|
|
* data representation class name of <CODE>"[B"</CODE> (byte array).
|
|
*
|
|
* @param mimeType MIME media type string.
|
|
*
|
|
* @exception NullPointerException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null.
|
|
* @exception IllegalArgumentException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not
|
|
* obey the syntax for a MIME media type string.
|
|
*/
|
|
public BYTE_ARRAY (String mimeType) {
|
|
super (mimeType, "[B");
|
|
}
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/plain"</CODE>,
|
|
* encoded in the host platform encoding.
|
|
* See {@link DocFlavor#hostEncoding hostEncoding}
|
|
* Print data representation class name =
|
|
* <CODE>"[B"</CODE> (byte array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_PLAIN_HOST =
|
|
new BYTE_ARRAY ("text/plain; charset="+hostEncoding);
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-8"</CODE>,
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_PLAIN_UTF_8 =
|
|
new BYTE_ARRAY ("text/plain; charset=utf-8");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16"</CODE>,
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_PLAIN_UTF_16 =
|
|
new BYTE_ARRAY ("text/plain; charset=utf-16");
|
|
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16be"</CODE>
|
|
* (big-endian byte ordering),
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_PLAIN_UTF_16BE =
|
|
new BYTE_ARRAY ("text/plain; charset=utf-16be");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16le"</CODE>
|
|
* (little-endian byte ordering),
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_PLAIN_UTF_16LE =
|
|
new BYTE_ARRAY ("text/plain; charset=utf-16le");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=us-ascii"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"[B"</CODE> (byte array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_PLAIN_US_ASCII =
|
|
new BYTE_ARRAY ("text/plain; charset=us-ascii");
|
|
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/html"</CODE>,
|
|
* encoded in the host platform encoding.
|
|
* See {@link DocFlavor#hostEncoding hostEncoding}
|
|
* Print data representation class name =
|
|
* <CODE>"[B"</CODE> (byte array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_HTML_HOST =
|
|
new BYTE_ARRAY ("text/html; charset="+hostEncoding);
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-8"</CODE>,
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_HTML_UTF_8 =
|
|
new BYTE_ARRAY ("text/html; charset=utf-8");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16"</CODE>,
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_HTML_UTF_16 =
|
|
new BYTE_ARRAY ("text/html; charset=utf-16");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16be"</CODE>
|
|
* (big-endian byte ordering),
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_HTML_UTF_16BE =
|
|
new BYTE_ARRAY ("text/html; charset=utf-16be");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16le"</CODE>
|
|
* (little-endian byte ordering),
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_HTML_UTF_16LE =
|
|
new BYTE_ARRAY ("text/html; charset=utf-16le");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=us-ascii"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"[B"</CODE> (byte array).
|
|
*/
|
|
public static final BYTE_ARRAY TEXT_HTML_US_ASCII =
|
|
new BYTE_ARRAY ("text/html; charset=us-ascii");
|
|
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/pdf"</CODE>, print
|
|
* data representation class name = <CODE>"[B"</CODE> (byte array).
|
|
*/
|
|
public static final BYTE_ARRAY PDF = new BYTE_ARRAY ("application/pdf");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/postscript"</CODE>,
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY POSTSCRIPT =
|
|
new BYTE_ARRAY ("application/postscript");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/vnd.hp-PCL"</CODE>,
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array).
|
|
*/
|
|
public static final BYTE_ARRAY PCL =
|
|
new BYTE_ARRAY ("application/vnd.hp-PCL");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/gif"</CODE>, print data
|
|
* representation class name = <CODE>"[B"</CODE> (byte array).
|
|
*/
|
|
public static final BYTE_ARRAY GIF = new BYTE_ARRAY ("image/gif");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/jpeg"</CODE>, print data
|
|
* representation class name = <CODE>"[B"</CODE> (byte array).
|
|
*/
|
|
public static final BYTE_ARRAY JPEG = new BYTE_ARRAY ("image/jpeg");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/png"</CODE>, print data
|
|
* representation class name = <CODE>"[B"</CODE> (byte array).
|
|
*/
|
|
public static final BYTE_ARRAY PNG = new BYTE_ARRAY ("image/png");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"application/octet-stream"</CODE>,
|
|
* print data representation class name = <CODE>"[B"</CODE> (byte
|
|
* array). The client must determine that data described
|
|
* using this DocFlavor is valid for the printer.
|
|
*/
|
|
public static final BYTE_ARRAY AUTOSENSE =
|
|
new BYTE_ARRAY ("application/octet-stream");
|
|
|
|
}
|
|
|
|
/**
|
|
* Class DocFlavor.INPUT_STREAM provides predefined static constant
|
|
* DocFlavor objects for example doc flavors using a byte stream ({@link
|
|
* java.io.InputStream java.io.InputStream}) as the print
|
|
* data representation class.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public static class INPUT_STREAM extends DocFlavor {
|
|
|
|
private static final long serialVersionUID = -7045842700749194127L;
|
|
|
|
/**
|
|
* Constructs a new doc flavor with the given MIME type and a print
|
|
* data representation class name of
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*
|
|
* @param mimeType MIME media type string.
|
|
*
|
|
* @exception NullPointerException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null.
|
|
* @exception IllegalArgumentException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not
|
|
* obey the syntax for a MIME media type string.
|
|
*/
|
|
public INPUT_STREAM (String mimeType) {
|
|
super (mimeType, "java.io.InputStream");
|
|
}
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/plain"</CODE>,
|
|
* encoded in the host platform encoding.
|
|
* See {@link DocFlavor#hostEncoding hostEncoding}
|
|
* Print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_PLAIN_HOST =
|
|
new INPUT_STREAM ("text/plain; charset="+hostEncoding);
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-8"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_PLAIN_UTF_8 =
|
|
new INPUT_STREAM ("text/plain; charset=utf-8");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_PLAIN_UTF_16 =
|
|
new INPUT_STREAM ("text/plain; charset=utf-16");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16be"</CODE>
|
|
* (big-endian byte ordering),
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_PLAIN_UTF_16BE =
|
|
new INPUT_STREAM ("text/plain; charset=utf-16be");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16le"</CODE>
|
|
* (little-endian byte ordering),
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_PLAIN_UTF_16LE =
|
|
new INPUT_STREAM ("text/plain; charset=utf-16le");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=us-ascii"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_PLAIN_US_ASCII =
|
|
new INPUT_STREAM ("text/plain; charset=us-ascii");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/html"</CODE>,
|
|
* encoded in the host platform encoding.
|
|
* See {@link DocFlavor#hostEncoding hostEncoding}
|
|
* Print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_HTML_HOST =
|
|
new INPUT_STREAM ("text/html; charset="+hostEncoding);
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-8"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_HTML_UTF_8 =
|
|
new INPUT_STREAM ("text/html; charset=utf-8");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_HTML_UTF_16 =
|
|
new INPUT_STREAM ("text/html; charset=utf-16");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16be"</CODE>
|
|
* (big-endian byte ordering),
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_HTML_UTF_16BE =
|
|
new INPUT_STREAM ("text/html; charset=utf-16be");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16le"</CODE>
|
|
* (little-endian byte ordering),
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_HTML_UTF_16LE =
|
|
new INPUT_STREAM ("text/html; charset=utf-16le");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=us-ascii"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM TEXT_HTML_US_ASCII =
|
|
new INPUT_STREAM ("text/html; charset=us-ascii");
|
|
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/pdf"</CODE>, print
|
|
* data representation class name = <CODE>"java.io.InputStream"</CODE>
|
|
* (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM PDF = new INPUT_STREAM ("application/pdf");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/postscript"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM POSTSCRIPT =
|
|
new INPUT_STREAM ("application/postscript");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/vnd.hp-PCL"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM PCL =
|
|
new INPUT_STREAM ("application/vnd.hp-PCL");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/gif"</CODE>, print data
|
|
* representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM GIF = new INPUT_STREAM ("image/gif");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/jpeg"</CODE>, print data
|
|
* representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM JPEG = new INPUT_STREAM ("image/jpeg");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/png"</CODE>, print data
|
|
* representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
*/
|
|
public static final INPUT_STREAM PNG = new INPUT_STREAM ("image/png");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"application/octet-stream"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.io.InputStream"</CODE> (byte stream).
|
|
* The client must determine that data described
|
|
* using this DocFlavor is valid for the printer.
|
|
*/
|
|
public static final INPUT_STREAM AUTOSENSE =
|
|
new INPUT_STREAM ("application/octet-stream");
|
|
|
|
}
|
|
|
|
/**
|
|
* Class DocFlavor.URL provides predefined static constant DocFlavor
|
|
* objects.
|
|
* For example doc flavors using a Uniform Resource Locator ({@link
|
|
* java.net.URL java.net.URL}) as the print data
|
|
* representation class.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public static class URL extends DocFlavor {
|
|
|
|
/**
|
|
* Constructs a new doc flavor with the given MIME type and a print
|
|
* data representation class name of <CODE>"java.net.URL"</CODE>.
|
|
*
|
|
* @param mimeType MIME media type string.
|
|
*
|
|
* @exception NullPointerException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null.
|
|
* @exception IllegalArgumentException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not
|
|
* obey the syntax for a MIME media type string.
|
|
*/
|
|
public URL (String mimeType) {
|
|
super (mimeType, "java.net.URL");
|
|
}
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/plain"</CODE>,
|
|
* encoded in the host platform encoding.
|
|
* See {@link DocFlavor#hostEncoding hostEncoding}
|
|
* Print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_PLAIN_HOST =
|
|
new URL ("text/plain; charset="+hostEncoding);
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-8"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_PLAIN_UTF_8 =
|
|
new URL ("text/plain; charset=utf-8");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>java.net.URL""</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_PLAIN_UTF_16 =
|
|
new URL ("text/plain; charset=utf-16");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16be"</CODE>
|
|
* (big-endian byte ordering),
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_PLAIN_UTF_16BE =
|
|
new URL ("text/plain; charset=utf-16be");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=utf-16le"</CODE>
|
|
* (little-endian byte ordering),
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_PLAIN_UTF_16LE =
|
|
new URL ("text/plain; charset=utf-16le");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/plain; charset=us-ascii"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_PLAIN_US_ASCII =
|
|
new URL ("text/plain; charset=us-ascii");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/html"</CODE>,
|
|
* encoded in the host platform encoding.
|
|
* See {@link DocFlavor#hostEncoding hostEncoding}
|
|
* Print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_HTML_HOST =
|
|
new URL ("text/html; charset="+hostEncoding);
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-8"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_HTML_UTF_8 =
|
|
new URL ("text/html; charset=utf-8");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_HTML_UTF_16 =
|
|
new URL ("text/html; charset=utf-16");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16be"</CODE>
|
|
* (big-endian byte ordering),
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_HTML_UTF_16BE =
|
|
new URL ("text/html; charset=utf-16be");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=utf-16le"</CODE>
|
|
* (little-endian byte ordering),
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_HTML_UTF_16LE =
|
|
new URL ("text/html; charset=utf-16le");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"text/html; charset=us-ascii"</CODE>,
|
|
* print data representation class name =
|
|
* <CODE>"java.net.URL"</CODE> (byte stream).
|
|
*/
|
|
public static final URL TEXT_HTML_US_ASCII =
|
|
new URL ("text/html; charset=us-ascii");
|
|
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/pdf"</CODE>, print
|
|
* data representation class name = <CODE>"java.net.URL"</CODE>.
|
|
*/
|
|
public static final URL PDF = new URL ("application/pdf");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/postscript"</CODE>,
|
|
* print data representation class name = <CODE>"java.net.URL"</CODE>.
|
|
*/
|
|
public static final URL POSTSCRIPT = new URL ("application/postscript");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"application/vnd.hp-PCL"</CODE>,
|
|
* print data representation class name = <CODE>"java.net.URL"</CODE>.
|
|
*/
|
|
public static final URL PCL = new URL ("application/vnd.hp-PCL");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/gif"</CODE>, print data
|
|
* representation class name = <CODE>"java.net.URL"</CODE>.
|
|
*/
|
|
public static final URL GIF = new URL ("image/gif");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/jpeg"</CODE>, print data
|
|
* representation class name = <CODE>"java.net.URL"</CODE>.
|
|
*/
|
|
public static final URL JPEG = new URL ("image/jpeg");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"image/png"</CODE>, print data
|
|
* representation class name = <CODE>"java.net.URL"</CODE>.
|
|
*/
|
|
public static final URL PNG = new URL ("image/png");
|
|
|
|
/**
|
|
* Doc flavor with MIME type =
|
|
* <CODE>"application/octet-stream"</CODE>,
|
|
* print data representation class name = <CODE>"java.net.URL"</CODE>.
|
|
* The client must determine that data described
|
|
* using this DocFlavor is valid for the printer.
|
|
*/
|
|
public static final URL AUTOSENSE = new URL ("application/octet-stream");
|
|
|
|
}
|
|
|
|
/**
|
|
* Class DocFlavor.CHAR_ARRAY provides predefined static constant
|
|
* DocFlavor objects for example doc flavors using a character array
|
|
* (<CODE>char[]</CODE>) as the print data representation class. As such,
|
|
* the character set is Unicode.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public static class CHAR_ARRAY extends DocFlavor {
|
|
|
|
private static final long serialVersionUID = -8720590903724405128L;
|
|
|
|
/**
|
|
* Constructs a new doc flavor with the given MIME type and a print
|
|
* data representation class name of
|
|
* <CODE>"[C"</CODE> (character array).
|
|
*
|
|
* @param mimeType MIME media type string. If it is a text media
|
|
* type, it is assumed to contain a
|
|
* <CODE>"charset=utf-16"</CODE> parameter.
|
|
*
|
|
* @exception NullPointerException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null.
|
|
* @exception IllegalArgumentException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not
|
|
* obey the syntax for a MIME media type string.
|
|
*/
|
|
public CHAR_ARRAY (String mimeType) {
|
|
super (mimeType, "[C");
|
|
}
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/plain;
|
|
* charset=utf-16"</CODE>, print data representation class name =
|
|
* <CODE>"[C"</CODE> (character array).
|
|
*/
|
|
public static final CHAR_ARRAY TEXT_PLAIN =
|
|
new CHAR_ARRAY ("text/plain; charset=utf-16");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/html;
|
|
* charset=utf-16"</CODE>, print data representation class name =
|
|
* <CODE>"[C"</CODE> (character array).
|
|
*/
|
|
public static final CHAR_ARRAY TEXT_HTML =
|
|
new CHAR_ARRAY ("text/html; charset=utf-16");
|
|
|
|
}
|
|
|
|
/**
|
|
* Class DocFlavor.STRING provides predefined static constant DocFlavor
|
|
* objects for example doc flavors using a string ({@link java.lang.String
|
|
* java.lang.String}) as the print data representation class.
|
|
* As such, the character set is Unicode.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public static class STRING extends DocFlavor {
|
|
|
|
private static final long serialVersionUID = 4414407504887034035L;
|
|
|
|
/**
|
|
* Constructs a new doc flavor with the given MIME type and a print
|
|
* data representation class name of <CODE>"java.lang.String"</CODE>.
|
|
*
|
|
* @param mimeType MIME media type string. If it is a text media
|
|
* type, it is assumed to contain a
|
|
* <CODE>"charset=utf-16"</CODE> parameter.
|
|
*
|
|
* @exception NullPointerException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null.
|
|
* @exception IllegalArgumentException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not
|
|
* obey the syntax for a MIME media type string.
|
|
*/
|
|
public STRING (String mimeType) {
|
|
super (mimeType, "java.lang.String");
|
|
}
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/plain;
|
|
* charset=utf-16"</CODE>, print data representation class name =
|
|
* <CODE>"java.lang.String"</CODE>.
|
|
*/
|
|
public static final STRING TEXT_PLAIN =
|
|
new STRING ("text/plain; charset=utf-16");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/html;
|
|
* charset=utf-16"</CODE>, print data representation class name =
|
|
* <CODE>"java.lang.String"</CODE>.
|
|
*/
|
|
public static final STRING TEXT_HTML =
|
|
new STRING ("text/html; charset=utf-16");
|
|
}
|
|
|
|
/**
|
|
* Class DocFlavor.READER provides predefined static constant DocFlavor
|
|
* objects for example doc flavors using a character stream ({@link
|
|
* java.io.Reader java.io.Reader}) as the print data
|
|
* representation class. As such, the character set is Unicode.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public static class READER extends DocFlavor {
|
|
|
|
private static final long serialVersionUID = 7100295812579351567L;
|
|
|
|
/**
|
|
* Constructs a new doc flavor with the given MIME type and a print
|
|
* data representation class name of\
|
|
* <CODE>"java.io.Reader"</CODE> (character stream).
|
|
*
|
|
* @param mimeType MIME media type string. If it is a text media
|
|
* type, it is assumed to contain a
|
|
* <CODE>"charset=utf-16"</CODE> parameter.
|
|
*
|
|
* @exception NullPointerException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null.
|
|
* @exception IllegalArgumentException
|
|
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not
|
|
* obey the syntax for a MIME media type string.
|
|
*/
|
|
public READER (String mimeType) {
|
|
super (mimeType, "java.io.Reader");
|
|
}
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/plain;
|
|
* charset=utf-16"</CODE>, print data representation class name =
|
|
* <CODE>"java.io.Reader"</CODE> (character stream).
|
|
*/
|
|
public static final READER TEXT_PLAIN =
|
|
new READER ("text/plain; charset=utf-16");
|
|
|
|
/**
|
|
* Doc flavor with MIME type = <CODE>"text/html;
|
|
* charset=utf-16"</CODE>, print data representation class name =
|
|
* <CODE>"java.io.Reader"</CODE> (character stream).
|
|
*/
|
|
public static final READER TEXT_HTML =
|
|
new READER ("text/html; charset=utf-16");
|
|
|
|
}
|
|
|
|
/**
|
|
* Class DocFlavor.SERVICE_FORMATTED provides predefined static constant
|
|
* DocFlavor objects for example doc flavors for service formatted print
|
|
* data.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public static class SERVICE_FORMATTED extends DocFlavor {
|
|
|
|
private static final long serialVersionUID = 6181337766266637256L;
|
|
|
|
/**
|
|
* Constructs a new doc flavor with a MIME type of
|
|
* <CODE>"application/x-java-jvm-local-objectref"</CODE> indicating
|
|
* service formatted print data and the given print data
|
|
* representation class name.
|
|
*
|
|
* @param className Fully-qualified representation class name.
|
|
*
|
|
* @exception NullPointerException
|
|
* (unchecked exception) Thrown if <CODE>className</CODE> is
|
|
* null.
|
|
*/
|
|
public SERVICE_FORMATTED (String className) {
|
|
super ("application/x-java-jvm-local-objectref", className);
|
|
}
|
|
|
|
/**
|
|
* Service formatted print data doc flavor with print data
|
|
* representation class name =
|
|
* <CODE>"java.awt.image.renderable.RenderableImage"</CODE>
|
|
* (renderable image object).
|
|
*/
|
|
public static final SERVICE_FORMATTED RENDERABLE_IMAGE =
|
|
new SERVICE_FORMATTED("java.awt.image.renderable.RenderableImage");
|
|
|
|
/**
|
|
* Service formatted print data doc flavor with print data
|
|
* representation class name = <CODE>"java.awt.print.Printable"</CODE>
|
|
* (printable object).
|
|
*/
|
|
public static final SERVICE_FORMATTED PRINTABLE =
|
|
new SERVICE_FORMATTED ("java.awt.print.Printable");
|
|
|
|
/**
|
|
* Service formatted print data doc flavor with print data
|
|
* representation class name = <CODE>"java.awt.print.Pageable"</CODE>
|
|
* (pageable object).
|
|
*/
|
|
public static final SERVICE_FORMATTED PAGEABLE =
|
|
new SERVICE_FORMATTED ("java.awt.print.Pageable");
|
|
|
|
}
|
|
|
|
}
|