| /* | |
| * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| package javax.print; | |
| import java.io.IOException; | |
| import java.io.ObjectInputStream; | |
| import java.io.ObjectOutputStream; | |
| import java.io.Serial; | |
| import java.io.Serializable; | |
| /** | |
| * Class {@code DocFlavor} 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="https://www.rfc-editor.org/info/rfc2045">RFC 2045</a> and | |
| * <a href="https://www.rfc-editor.org/info/rfc2046">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.base/java/lang/package-summary.html#charenc"> | |
| * character encodings</a> for more information on the character encodings | |
| * supported on the Java platform. | |
| * <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 Class#getName() Class.getName()} method. (Thus the | |
| * class name for {@code byte[]} is {@code "[B"}, for {@code char[]} it is | |
| * {@code "[C"}.) | |
| * </ul> | |
| * A {@code DocPrintJob} obtains its print data by means of interface | |
| * {@link Doc Doc}. A {@code Doc} object lets the {@code DocPrintJob} determine | |
| * the doc flavor the client can supply. A {@code Doc} object also lets the | |
| * {@code DocPrintJob} obtain an instance of the doc flavor's representation | |
| * class, from which the {@code DocPrintJob} then obtains the actual print data. | |
| * | |
| * <hr> | |
| * <h2>Client Formatted Print Data</h2> | |
| * 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 | |
| * {@code 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} 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} | |
| * 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[]}) -- The print data consists of the | |
| * Unicode characters in the array. | |
| * <li>{@code String} -- The print data consists of the Unicode characters in | |
| * the string. | |
| * <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. | |
| * <li>Byte array ({@code byte[]}) -- 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. | |
| * <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. | |
| * When the representation class is a {@code URL}, the print service itself | |
| * accesses and downloads the document directly from its {@code 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 {@code URL} print data flavor to print a document at a | |
| * restricted {@code URL} that the client can see but the printer cannot see. | |
| * This also means you should not use a {@code URL} print data flavor to print | |
| * a document stored in a local file that is not available at a {@code 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 {@code URL} or file and use an input | |
| * stream data flavor. | |
| * </ul> | |
| * | |
| * <hr> | |
| * <h2>Default and Platform Encodings</h2> | |
| * For byte print data where the doc flavor's MIME type does not include a | |
| * {@code charset} 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 {@code CharSet} which | |
| * corresponds to this and is suitable for use in a mime-type for a | |
| * {@code 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 {@code DocFlavors} may be used. | |
| * <p> | |
| * See <a href="../../../java.base/java/lang/package-summary.html#charenc"> | |
| * character encodings</a> for more information on the character encodings | |
| * supported on the Java platform. | |
| * | |
| * <hr> | |
| * <h2>Recommended DocFlavors</h2> | |
| * The Java Print Service API does not define any mandatorily supported | |
| * {@code 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 {@code DocFlavor} declare predefined static constant | |
| * {@code DocFlavor} objects for these example doc flavors; class | |
| * {@code DocFlavor}'s constructor can be used to create an arbitrary doc | |
| * flavor. | |
| * <ul> | |
| * <li>Preformatted text | |
| * <table class="striped"> | |
| * <caption>MIME-Types and their descriptions</caption> | |
| * <thead> | |
| * <tr> | |
| * <th scope="col">MIME-Type | |
| * <th scope="col">Description | |
| * </thead> | |
| * <tbody> | |
| * <tr> | |
| * <th scope="row">{@code "text/plain"} | |
| * <td>Plain text in the default character set (US-ASCII) | |
| * <tr> | |
| * <th scope="row"><code> "text/plain; charset=<i>xxx</i>"</code> | |
| * <td>Plain text in character set <i>xxx</i> | |
| * <tr> | |
| * <th scope="row">{@code "text/html"} | |
| * <td>HyperText Markup Language in the default character set (US-ASCII) | |
| * <tr> | |
| * <th scope="row"><code> "text/html; charset=<i>xxx</i>"</code> | |
| * <td>HyperText Markup Language in character set <i>xxx</i> | |
| * </tbody> | |
| * </table> | |
| * 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). | |
| * <li>Preformatted page description language (PDL) documents | |
| * <table class="striped"> | |
| * <caption>MIME-Types and their descriptions</caption> | |
| * <thead> | |
| * <tr> | |
| * <th scope="col">MIME-Type | |
| * <th scope="col">Description | |
| * </thead> | |
| * <tbody> | |
| * <tr> | |
| * <th scope="row">{@code "application/pdf"} | |
| * <td>Portable Document Format document | |
| * <tr> | |
| * <th scope="row">{@code "application/postscript"} | |
| * <td>PostScript document | |
| * <tr> | |
| * <th scope="row">{@code "application/vnd.hp-PCL"} | |
| * <td>Printer Control Language document | |
| * </tbody> | |
| * </table> | |
| * In general, preformatted PDL print data is provided in a byte oriented | |
| * representation class (byte array, {@code InputStream}, {@code URL}). | |
| * <li>Preformatted images | |
| * <table class="striped"> | |
| * <caption>MIME-Types and their descriptions</caption> | |
| * <thead> | |
| * <tr> | |
| * <th scope="col">MIME-Type | |
| * <th scope="col">Description | |
| * </thead> | |
| * <tbody> | |
| * <tr> | |
| * <th scope="row">{@code "image/gif"} | |
| * <td>Graphics Interchange Format image | |
| * <tr> | |
| * <th scope="row">{@code "image/jpeg"} | |
| * <td>Joint Photographic Experts Group image | |
| * <tr> | |
| * <th scope="row">{@code "image/png"} | |
| * <td>Portable Network Graphics image | |
| * </tbody> | |
| * </table> | |
| * In general, preformatted image print data is provided in a byte oriented | |
| * representation class (byte array, {@code InputStream}, {@code URL}). | |
| * <li>Preformatted autosense print data | |
| * <table class="striped"> | |
| * <caption>MIME-Types and their descriptions</caption> | |
| * <thead> | |
| * <tr> | |
| * <th scope="col">MIME-Type | |
| * <th scope="col">Description | |
| * </thead> | |
| * <tbody> | |
| * <tr> | |
| * <th scope="row">{@code "application/octet-stream"} | |
| * <td>The print data format is unspecified (just an octet stream) | |
| * </tbody> | |
| * </table> | |
| * 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, {@code InputStream}, {@code URL}). | |
| * </ul> | |
| * | |
| * <hr> | |
| * <h2>Service Formatted Print Data</h2> | |
| * 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} 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"} 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 {@code DocFlavor} declare predefined | |
| * static constant {@code DocFlavor} objects for these example doc flavors; | |
| * class {@code 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. | |
| * <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. | |
| * <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> | |
| * | |
| * <hr> | |
| * <h2>Pre-defined Doc Flavors</h2> | |
| * 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")} | |
| * <br>· | |
| * {@code ("text/plain; charset=us-ascii", "java.io.InputStream")} | |
| * <br>· | |
| * {@code ("text/plain; charset=utf-8", "java.io.InputStream")} | |
| * <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")} | |
| * </ul> | |
| * 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." | |
| * </ul> | |
| * The client must itself perform all plain text print data formatting not | |
| * addressed by the above requirements. | |
| * | |
| * <h2>Design Rationale</h2> | |
| * Class {@code DocFlavor} in package {@code javax.print} is similar to class | |
| * {@link java.awt.datatransfer.DataFlavor}. Class {@code DataFlavor} 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. | |
| * <li>The implementation of class {@code java.awt.datatransfer.DataFlavor} | |
| * does not guarantee that equivalent data flavors will have the same | |
| * serialized representation. {@code DocFlavor} does, and can be used in | |
| * services which need this. | |
| * <li>The implementation of class {@code java.awt.datatransfer.DataFlavor} | |
| * includes a human presentable name as part of the serialized representation. | |
| * This is not appropriate as part of a service matching constraint. | |
| * </ol> | |
| * Class {@code 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> | |
| * Class {@code DocFlavor}'s serialized representation also contains the | |
| * fully-qualified class <i>name</i> of the representation class (a | |
| * {@code String} object), rather than the representation class itself (a | |
| * {@code 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. | |
| * | |
| * @spec https://www.rfc-editor.org/info/rfc2045 | |
| * RFC 2045: Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies | |
| * @spec https://www.rfc-editor.org/info/rfc2046 | |
| * RFC 2046: Multipurpose Internet Mail Extensions (MIME) Part Two: Media Types | |
| * @author Alan Kaminsky | |
| */ | |
| public class DocFlavor implements Serializable, Cloneable { | |
| /** | |
| * Use serialVersionUID from JDK 1.4 for interoperability. | |
| */ | |
| @Serial | |
| private static final long serialVersionUID = -4512080796965449721L; | |
| /** | |
| * A string representing the host operating system encoding. This will | |
| * follow the conventions documented in | |
| * <a href="https://www.rfc-editor.org/info/rfc2278"> | |
| * <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 {@code DocFlavor}. | |
| * This is the charset for all the "HOST" pre-defined {@code DocFlavors} in | |
| * the executing VM. | |
| * @spec https://www.rfc-editor.org/info/rfc2278 | |
| * RFC 2278: IANA Charset Registration Procedures | |
| */ | |
| public static final String hostEncoding = System.getProperty("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 | |
| * @throws NullPointerException if {@code mimeType} or {@code className} is | |
| * {@code null} | |
| * @throws IllegalArgumentException if {@code mimeType} 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} 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. | |
| * | |
| * @param paramName the name of the parameter. This name is internally | |
| * converted to the canonical lower case format before performing | |
| * the match. | |
| * @return a string representing a mime parameter, or {@code null} if that | |
| * parameter is not in the mime type string | |
| * @throws NullPointerException if paramName is {@code null} | |
| */ | |
| public String getParameter(String paramName) { | |
| return 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} 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 {@code null}, is an instance of | |
| * {@code DocFlavor}, 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 {@code Object} to test | |
| * @return {@code true} if this doc flavor object equals {@code obj}, | |
| * {@code false} otherwise | |
| */ | |
| public boolean equals(Object obj) { | |
| return obj instanceof DocFlavor other && | |
| getStringValue().equals(other.getStringValue()); | |
| } | |
| /** | |
| * Returns this doc flavor object's string value. | |
| * | |
| * @return the string value | |
| */ | |
| private String getStringValue() { | |
| if (myStringValue == null) { | |
| myStringValue = myMimeType + "; class=\"" + myClassName + "\""; | |
| } | |
| return myStringValue; | |
| } | |
| /** | |
| * Write the instance to a stream (ie serialize the object). | |
| * | |
| * @param s the output stream | |
| * @throws IOException if I/O errors occur while writing to the underlying | |
| * stream | |
| */ | |
| @Serial | |
| private void writeObject(ObjectOutputStream s) throws IOException { | |
| s.defaultWriteObject(); | |
| s.writeObject(myMimeType.getMimeType()); | |
| } | |
| /** | |
| * Reconstitute an instance from a stream (that is, deserialize it). | |
| * | |
| * @param s the input stream | |
| * @throws ClassNotFoundException if the class of a serialized object could | |
| * not be found | |
| * @throws IOException if I/O errors occur while reading from the underlying | |
| * stream | |
| * @serialData The serialised form of a {@code DocFlavor} is the | |
| * {@code String} naming the representation class followed by | |
| * the {@code String} representing the canonical form of the | |
| * mime type | |
| */ | |
| @Serial | |
| private void readObject(ObjectInputStream s) | |
| throws ClassNotFoundException, IOException { | |
| s.defaultReadObject(); | |
| myMimeType = new MimeType((String)s.readObject()); | |
| } | |
| /** | |
| * Class {@code DocFlavor.BYTE_ARRAY} provides predefined static constant | |
| * {@code DocFlavor} objects for example doc flavors using a byte array | |
| * ({@code byte[]}) as the print data representation class. | |
| * | |
| * @author Alan Kaminsky | |
| */ | |
| public static class BYTE_ARRAY extends DocFlavor { | |
| /** | |
| * Use serialVersionUID from JDK 1.4 for interoperability. | |
| */ | |
| @Serial | |
| 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"} (byte array). | |
| * | |
| * @param mimeType MIME media type string | |
| * @throws NullPointerException if {@code mimeType} is {@code null} | |
| * @throws IllegalArgumentException if {@code mimeType} 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"}, encoded in the host | |
| * platform encoding. See {@link DocFlavor#hostEncoding hostEncoding}. | |
| * Print data representation class name = {@code "[B"} (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"}, | |
| * print data representation class name = {@code "[B"} (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"}, | |
| * print data representation class name = {@code "[B"} (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"} | |
| * (big-endian byte ordering), print data representation class name = | |
| * {@code "[B"} (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"} | |
| * (little-endian byte ordering), print data representation class name = | |
| * {@code "[B"} (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"}, | |
| * print data representation class name = {@code "[B"} (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"}, encoded in the host | |
| * platform encoding. See {@link DocFlavor#hostEncoding hostEncoding}. | |
| * Print data representation class name = {@code "[B"} (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"}, print | |
| * data representation class name = {@code "[B"} (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"}, | |
| * print data representation class name = {@code "[B"} (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"} | |
| * (big-endian byte ordering), print data representation class name = | |
| * {@code "[B"} (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"} | |
| * (little-endian byte ordering), print data representation class name = | |
| * {@code "[B"} (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"}, | |
| * print data representation class name = {@code "[B"} (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"}, print data | |
| * representation class name = {@code "[B"} (byte array). | |
| */ | |
| public static final BYTE_ARRAY PDF = new BYTE_ARRAY ("application/pdf"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/postscript"}, print | |
| * data representation class name = {@code "[B"} (byte array). | |
| */ | |
| public static final BYTE_ARRAY POSTSCRIPT = | |
| new BYTE_ARRAY ("application/postscript"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/vnd.hp-PCL"}, print | |
| * data representation class name = {@code "[B"} (byte array). | |
| */ | |
| public static final BYTE_ARRAY PCL = | |
| new BYTE_ARRAY ("application/vnd.hp-PCL"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/gif"}, print data | |
| * representation class name = {@code "[B"} (byte array). | |
| */ | |
| public static final BYTE_ARRAY GIF = new BYTE_ARRAY ("image/gif"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/jpeg"}, print data | |
| * representation class name = {@code "[B"} (byte array). | |
| */ | |
| public static final BYTE_ARRAY JPEG = new BYTE_ARRAY ("image/jpeg"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/png"}, print data | |
| * representation class name = {@code "[B"} (byte array). | |
| */ | |
| public static final BYTE_ARRAY PNG = new BYTE_ARRAY ("image/png"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/octet-stream"}, print | |
| * data representation class name = {@code "[B"} (byte array). The | |
| * client must determine that data described using this | |
| * {@code DocFlavor} is valid for the printer. | |
| */ | |
| public static final BYTE_ARRAY AUTOSENSE = | |
| new BYTE_ARRAY ("application/octet-stream"); | |
| } | |
| /** | |
| * Class {@code DocFlavor.INPUT_STREAM} provides predefined static constant | |
| * {@code DocFlavor} objects for example doc flavors using a byte stream | |
| * ({@link java.io.InputStream java.io.InputStream}) as the print data | |
| * representation class. | |
| * | |
| * @author Alan Kaminsky | |
| */ | |
| public static class INPUT_STREAM extends DocFlavor { | |
| /** | |
| * Use serialVersionUID from JDK 1.4 for interoperability. | |
| */ | |
| @Serial | |
| 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"} (byte | |
| * stream). | |
| * | |
| * @param mimeType MIME media type string | |
| * @throws NullPointerException if {@code mimeType} is {@code null} | |
| * @throws IllegalArgumentException if {@code mimeType} 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"}, encoded in the host | |
| * platform encoding. See {@link DocFlavor#hostEncoding hostEncoding}. | |
| * Print data representation class name = {@code "java.io.InputStream"} | |
| * (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"}, | |
| * print data representation class name = {@code "java.io.InputStream"} | |
| * (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"}, | |
| * print data representation class name = {@code "java.io.InputStream"} | |
| * (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"} | |
| * (big-endian byte ordering), print data representation class name = | |
| * {@code "java.io.InputStream"} (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"} | |
| * (little-endian byte ordering), print data representation class name = | |
| * {@code "java.io.InputStream"} (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"}, | |
| * print data representation class name = {@code "java.io.InputStream"} | |
| * (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"}, encoded in the host | |
| * platform encoding. See {@link DocFlavor#hostEncoding hostEncoding}. | |
| * Print data representation class name = {@code "java.io.InputStream"} | |
| * (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"}, print | |
| * data representation class name = {@code "java.io.InputStream"} (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"}, | |
| * print data representation class name = {@code "java.io.InputStream"} | |
| * (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"} | |
| * (big-endian byte ordering), print data representation class name = | |
| * {@code "java.io.InputStream"} (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"} | |
| * (little-endian byte ordering), print data representation class name = | |
| * {@code "java.io.InputStream"} (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"}, | |
| * print data representation class name = {@code "java.io.InputStream"} | |
| * (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"}, print data | |
| * representation class name = {@code "java.io.InputStream"} (byte | |
| * stream). | |
| */ | |
| public static final INPUT_STREAM PDF = new INPUT_STREAM ("application/pdf"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/postscript"}, print | |
| * data representation class name = {@code "java.io.InputStream"} (byte | |
| * stream). | |
| */ | |
| public static final INPUT_STREAM POSTSCRIPT = | |
| new INPUT_STREAM ("application/postscript"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/vnd.hp-PCL"}, print | |
| * data representation class name = {@code "java.io.InputStream"} (byte | |
| * stream). | |
| */ | |
| public static final INPUT_STREAM PCL = | |
| new INPUT_STREAM ("application/vnd.hp-PCL"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/gif"}, print data | |
| * representation class name = {@code "java.io.InputStream"} (byte | |
| * stream). | |
| */ | |
| public static final INPUT_STREAM GIF = new INPUT_STREAM ("image/gif"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/jpeg"}, print data | |
| * representation class name = {@code "java.io.InputStream"} (byte | |
| * stream). | |
| */ | |
| public static final INPUT_STREAM JPEG = new INPUT_STREAM ("image/jpeg"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/png"}, print data | |
| * representation class name = {@code "java.io.InputStream"} (byte | |
| * stream). | |
| */ | |
| public static final INPUT_STREAM PNG = new INPUT_STREAM ("image/png"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/octet-stream"}, print | |
| * data representation class name = {@code "java.io.InputStream"} (byte | |
| * stream). The client must determine that data described using this | |
| * {@code DocFlavor} is valid for the printer. | |
| */ | |
| public static final INPUT_STREAM AUTOSENSE = | |
| new INPUT_STREAM ("application/octet-stream"); | |
| } | |
| /** | |
| * Class {@code DocFlavor.URL} provides predefined static constant | |
| * {@code DocFlavor} objects. For example doc flavors using a Uniform | |
| * Resource Locator ({@link java.net.URL java.net.URL}) as the print data | |
| * representation class. | |
| * | |
| * @author Alan Kaminsky | |
| */ | |
| public static class URL extends DocFlavor { | |
| /** | |
| * Use serialVersionUID from JDK 1.4 for interoperability. | |
| */ | |
| @Serial | |
| private static final long serialVersionUID = 2936725788144902062L; | |
| /** | |
| * Constructs a new doc flavor with the given MIME type and a print data | |
| * representation class name of {@code "java.net.URL"}. | |
| * | |
| * @param mimeType MIME media type string | |
| * @throws NullPointerException if {@code mimeType} is {@code null} | |
| * @throws IllegalArgumentException if {@code mimeType} 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"}, encoded in the host | |
| * platform encoding. See {@link DocFlavor#hostEncoding hostEncoding}. | |
| * Print data representation class name = {@code "java.net.URL"} (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"}, | |
| * print data representation class name = {@code "java.net.URL"} (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"}, | |
| * print data representation class name = {@code java.net.URL""} (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"} | |
| * (big-endian byte ordering), print data representation class name = | |
| * {@code "java.net.URL"} (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"} | |
| * (little-endian byte ordering), print data representation class name = | |
| * {@code "java.net.URL"} (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"}, | |
| * print data representation class name = {@code "java.net.URL"} (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"}, encoded in the host | |
| * platform encoding. See {@link DocFlavor#hostEncoding hostEncoding}. | |
| * Print data representation class name = {@code "java.net.URL"} (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"}, print | |
| * data representation class name = {@code "java.net.URL"} (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"}, | |
| * print data representation class name = {@code "java.net.URL"} (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"} | |
| * (big-endian byte ordering), print data representation class name = | |
| * {@code "java.net.URL"} (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"} | |
| * (little-endian byte ordering), print data representation class name = | |
| * {@code "java.net.URL"} (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"}, | |
| * print data representation class name = {@code "java.net.URL"} (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"}, print data | |
| * representation class name = {@code "java.net.URL"}. | |
| */ | |
| public static final URL PDF = new URL ("application/pdf"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/postscript"}, print | |
| * data representation class name = {@code "java.net.URL"}. | |
| */ | |
| public static final URL POSTSCRIPT = new URL ("application/postscript"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/vnd.hp-PCL"}, print | |
| * data representation class name = {@code "java.net.URL"}. | |
| */ | |
| public static final URL PCL = new URL ("application/vnd.hp-PCL"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/gif"}, print data | |
| * representation class name = {@code "java.net.URL"}. | |
| */ | |
| public static final URL GIF = new URL ("image/gif"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/jpeg"}, print data | |
| * representation class name = {@code "java.net.URL"}. | |
| */ | |
| public static final URL JPEG = new URL ("image/jpeg"); | |
| /** | |
| * Doc flavor with MIME type = {@code "image/png"}, print data | |
| * representation class name = {@code "java.net.URL"}. | |
| */ | |
| public static final URL PNG = new URL ("image/png"); | |
| /** | |
| * Doc flavor with MIME type = {@code "application/octet-stream"}, print | |
| * data representation class name = {@code "java.net.URL"}. The client | |
| * must determine that data described using this {@code DocFlavor} is | |
| * valid for the printer. | |
| */ | |
| public static final URL AUTOSENSE = new URL ("application/octet-stream"); | |
| } | |
| /** | |
| * Class {@code DocFlavor.CHAR_ARRAY} provides predefined static constant | |
| * {@code DocFlavor} objects for example doc flavors using a character array | |
| * ({@code char[]}) as the print data representation class. As such, the | |
| * character set is Unicode. | |
| * | |
| * @author Alan Kaminsky | |
| */ | |
| public static class CHAR_ARRAY extends DocFlavor { | |
| /** | |
| * Use serialVersionUID from JDK 1.4 for interoperability. | |
| */ | |
| @Serial | |
| 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"} (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"} | |
| * parameter. | |
| * @throws NullPointerException if {@code mimeType} is {@code null} | |
| * @throws IllegalArgumentException if {@code mimeType} 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"}, | |
| * print data representation class name = {@code "[C"} (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"}, | |
| * print data representation class name = {@code "[C"} (character | |
| * array). | |
| */ | |
| public static final CHAR_ARRAY TEXT_HTML = | |
| new CHAR_ARRAY ("text/html; charset=utf-16"); | |
| } | |
| /** | |
| * Class {@code DocFlavor.STRING} provides predefined static constant | |
| * {@code DocFlavor} objects for example doc flavors using a string | |
| * ({@link String java.lang.String}) as the print data representation class. | |
| * As such, the character set is Unicode. | |
| * | |
| * @author Alan Kaminsky | |
| */ | |
| public static class STRING extends DocFlavor { | |
| /** | |
| * Use serialVersionUID from JDK 1.4 for interoperability. | |
| */ | |
| @Serial | |
| 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"}. | |
| * | |
| * @param mimeType MIME media type string. If it is a text media type, | |
| * it is assumed to contain a {@code "charset=utf-16"} | |
| * parameter. | |
| * @throws NullPointerException if {@code mimeType} is {@code null} | |
| * @throws IllegalArgumentException if {@code mimeType} 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"}, | |
| * print data representation class name = {@code "java.lang.String"}. | |
| */ | |
| public static final STRING TEXT_PLAIN = | |
| new STRING ("text/plain; charset=utf-16"); | |
| /** | |
| * Doc flavor with MIME type = {@code "text/html; charset=utf-16"}, | |
| * print data representation class name = {@code "java.lang.String"}. | |
| */ | |
| public static final STRING TEXT_HTML = | |
| new STRING ("text/html; charset=utf-16"); | |
| } | |
| /** | |
| * Class {@code DocFlavor.READER} provides predefined static constant | |
| * {@code 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. | |
| * | |
| * @author Alan Kaminsky | |
| */ | |
| public static class READER extends DocFlavor { | |
| /** | |
| * Use serialVersionUID from JDK 1.4 for interoperability. | |
| */ | |
| @Serial | |
| 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"} (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"} | |
| * parameter. | |
| * @throws NullPointerException if {@code mimeType} is {@code null} | |
| * @throws IllegalArgumentException if {@code mimeType} 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"}, | |
| * print data representation class name = {@code "java.io.Reader"} | |
| * (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"}, | |
| * print data representation class name = {@code "java.io.Reader"} | |
| * (character stream). | |
| */ | |
| public static final READER TEXT_HTML = | |
| new READER ("text/html; charset=utf-16"); | |
| } | |
| /** | |
| * Class {@code DocFlavor.SERVICE_FORMATTED} provides predefined static | |
| * constant {@code DocFlavor} objects for example doc flavors for service | |
| * formatted print data. | |
| * | |
| * @author Alan Kaminsky | |
| */ | |
| public static class SERVICE_FORMATTED extends DocFlavor { | |
| /** | |
| * Use serialVersionUID from JDK 1.4 for interoperability. | |
| */ | |
| @Serial | |
| private static final long serialVersionUID = 6181337766266637256L; | |
| /** | |
| * Constructs a new doc flavor with a MIME type of | |
| * {@code "application/x-java-jvm-local-objectref"} indicating service | |
| * formatted print data and the given print data representation class | |
| * name. | |
| * | |
| * @param className fully-qualified representation class name | |
| * @throws NullPointerException if {@code className} is {@code 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"} (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"} | |
| * (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"} | |
| * (pageable object). | |
| */ | |
| public static final SERVICE_FORMATTED PAGEABLE = | |
| new SERVICE_FORMATTED ("java.awt.print.Pageable"); | |
| } | |
| } |