author | malenkov |
Tue, 29 Oct 2013 17:01:06 +0400 | |
changeset 21278 | ef8a3a2a72f2 |
parent 20451 | 4cedf4e1560a |
child 22260 | c9185e010e03 |
permissions | -rw-r--r-- |
2 | 1 |
/* |
7668 | 2 |
* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. |
2 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 10 |
* |
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
5506 | 21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
2 | 24 |
*/ |
25 |
||
26 |
package javax.print; |
|
27 |
||
28 |
import java.io.IOException; |
|
29 |
import java.io.ObjectInputStream; |
|
30 |
import java.io.ObjectOutputStream; |
|
31 |
import java.io.Serializable; |
|
32 |
||
33 |
||
34 |
/** |
|
35 |
* Class <code>DocFlavor</code> encapsulates an object that specifies the |
|
36 |
* format in which print data is supplied to a {@link DocPrintJob}. |
|
37 |
* "Doc" is a short, easy-to-pronounce term that means "a piece of print data." |
|
38 |
* The print data format, or "doc flavor", consists of two things: |
|
39 |
* <UL> |
|
40 |
* <LI> |
|
41 |
* <B>MIME type.</B> This is a Multipurpose Internet Mail Extensions (MIME) |
|
42 |
* media type (as defined in <A HREF="http://www.ietf.org/rfc/rfc2045.txt">RFC |
|
43 |
* 2045</A> and <A HREF="http://www.ietf.org/rfc/rfc2046.txt">RFC 2046</A>) |
|
44 |
* that specifies how the print data is to be interpreted. |
|
45 |
* The charset of text data should be the IANA MIME-preferred name, or its |
|
46 |
* canonical name if no preferred name is specified. Additionally a few |
|
47 |
* historical names supported by earlier versions of the Java platform may |
|
48 |
* be recognized. |
|
49 |
* See <a href="../../java/lang/package-summary.html#charenc"> |
|
50 |
* character encodings</a> for more information on the character encodings |
|
51 |
* supported on the Java platform. |
|
52 |
* <P> |
|
53 |
* <LI> |
|
54 |
* <B>Representation class name.</B> This specifies the fully-qualified name of |
|
55 |
* the class of the object from which the actual print data comes, as returned |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
56 |
* by the {@link java.lang.Class#getName() Class.getName()} method. |
2 | 57 |
* (Thus the class name for <CODE>byte[]</CODE> is <CODE>"[B"</CODE>, for |
58 |
* <CODE>char[]</CODE> it is <CODE>"[C"</CODE>.) |
|
59 |
* </UL> |
|
60 |
* <P> |
|
61 |
* A <code>DocPrintJob</code> obtains its print data by means of interface |
|
62 |
* {@link Doc Doc}. A <code>Doc</code> object lets the <code>DocPrintJob</code> |
|
63 |
* determine the doc flavor the client can supply. A <code>Doc</code> object |
|
64 |
* also lets the <code>DocPrintJob</code> obtain an instance of the doc flavor's |
|
65 |
* representation class, from which the <code>DocPrintJob</code> then obtains |
|
66 |
* the actual print data. |
|
67 |
* <P> |
|
68 |
* <HR> |
|
69 |
* <H3>Client Formatted Print Data</H3> |
|
70 |
* There are two broad categories of print data, client formatted print data |
|
71 |
* and service formatted print data. |
|
72 |
* <P> |
|
73 |
* For <B>client formatted print data</B>, the client determines or knows the |
|
74 |
* print data format. |
|
75 |
* For example the client may have a JPEG encoded image, a URL for |
|
76 |
* HTML code, or a disk file containing plain text in some encoding, |
|
77 |
* possibly obtained from an external source, and |
|
78 |
* requires a way to describe the data format to the print service. |
|
79 |
* <p> |
|
80 |
* The doc flavor's representation class is a conduit for the JPS |
|
81 |
* <code>DocPrintJob</code> to obtain a sequence of characters or |
|
82 |
* bytes from the client. The |
|
83 |
* doc flavor's MIME type is one of the standard media types telling how to |
|
84 |
* interpret the sequence of characters or bytes. For a list of standard media |
|
85 |
* types, see the Internet Assigned Numbers Authority's (IANA's) <A |
|
5604
d5b97d8361d0
6952701: Use http://www.ietf.org/rfc for rfc references in jdk public APIs
sherman
parents:
1738
diff
changeset
|
86 |
* HREF="http://www.iana.org/assignments/media-types/">Media Types |
2 | 87 |
* Directory</A>. Interface {@link Doc Doc} provides two utility operations, |
88 |
* {@link Doc#getReaderForText() getReaderForText} and |
|
89 |
* {@link Doc#getStreamForBytes() getStreamForBytes()}, to help a |
|
90 |
* <code>Doc</code> object's client extract client formatted print data. |
|
91 |
* <P> |
|
92 |
* For client formatted print data, the print data representation class is |
|
93 |
* typically one of the following (although other representation classes are |
|
94 |
* permitted): |
|
95 |
* <UL> |
|
96 |
* <LI> |
|
97 |
* Character array (<CODE>char[]</CODE>) -- The print data consists of the |
|
21278 | 98 |
* Unicode characters in the array. |
2 | 99 |
* <P> |
100 |
* <LI> |
|
101 |
* <code>String</code> -- |
|
102 |
* The print data consists of the Unicode characters in the string. |
|
103 |
* <P> |
|
104 |
* <LI> |
|
105 |
* Character stream ({@link java.io.Reader java.io.Reader}) |
|
106 |
* -- The print data consists of the Unicode characters read from the stream |
|
107 |
* up to the end-of-stream. |
|
108 |
* <P> |
|
109 |
* <LI> |
|
110 |
* Byte array (<CODE>byte[]</CODE>) -- The print data consists of the bytes in |
|
111 |
* the array. The bytes are encoded in the character set specified by the doc |
|
112 |
* flavor's MIME type. If the MIME type does not specify a character set, the |
|
113 |
* default character set is US-ASCII. |
|
114 |
* <P> |
|
115 |
* <LI> |
|
116 |
* Byte stream ({@link java.io.InputStream java.io.InputStream}) -- |
|
117 |
* The print data consists of the bytes read from the stream up to the |
|
118 |
* end-of-stream. The bytes are encoded in the character set specified by the |
|
119 |
* doc flavor's MIME type. If the MIME type does not specify a character set, |
|
120 |
* the default character set is US-ASCII. |
|
121 |
||
122 |
* <LI> |
|
123 |
* Uniform Resource Locator ({@link java.net.URL URL}) |
|
124 |
* -- The print data consists of the bytes read from the URL location. |
|
125 |
* The bytes are encoded in the character set specified by the doc flavor's |
|
126 |
* MIME type. If the MIME type does not specify a character set, the default |
|
127 |
* character set is US-ASCII. |
|
128 |
* <P> |
|
129 |
* When the representation class is a URL, the print service itself accesses |
|
130 |
* and downloads the document directly from its URL address, without involving |
|
131 |
* the client. The service may be some form of network print service which |
|
132 |
* is executing in a different environment. |
|
133 |
* This means you should not use a URL print data flavor to print a |
|
134 |
* document at a restricted URL that the client can see but the printer cannot |
|
135 |
* see. This also means you should not use a URL print data flavor to print a |
|
136 |
* document stored in a local file that is not available at a URL |
|
137 |
* accessible independently of the client. |
|
138 |
* For example, a file that is not served up by an HTTP server or FTP server. |
|
139 |
* To print such documents, let the client open an input stream on the URL |
|
140 |
* or file and use an input stream data flavor. |
|
141 |
* </UL> |
|
142 |
* <p> |
|
143 |
* <HR> |
|
144 |
* <h3>Default and Platform Encodings</h3> |
|
145 |
* <P> |
|
146 |
* For byte print data where the doc flavor's MIME type does not include a |
|
147 |
* <CODE>charset</CODE> parameter, the Java Print Service instance assumes the |
|
148 |
* US-ASCII character set by default. This is in accordance with |
|
149 |
* <A HREF="http://www.ietf.org/rfc/rfc2046.txt">RFC 2046</A>, which says the |
|
150 |
* default character set is US-ASCII. Note that US-ASCII is a subset of |
|
151 |
* UTF-8, so in the future this may be widened if a future RFC endorses |
|
152 |
* UTF-8 as the default in a compatible manner. |
|
153 |
* <p> |
|
154 |
* Also note that this is different than the behaviour of the Java runtime |
|
155 |
* when interpreting a stream of bytes as text data. That assumes the |
|
156 |
* default encoding for the user's locale. Thus, when spooling a file in local |
|
157 |
* encoding to a Java Print Service it is important to correctly specify |
|
158 |
* the encoding. Developers working in the English locales should |
|
159 |
* be particularly conscious of this, as their platform encoding corresponds |
|
160 |
* to the default mime charset. By this coincidence that particular |
|
161 |
* case may work without specifying the encoding of platform data. |
|
162 |
* <p> |
|
163 |
* Every instance of the Java virtual machine has a default character encoding |
|
164 |
* determined during virtual-machine startup and typically depends upon the |
|
165 |
* locale and charset being used by the underlying operating system. |
|
21278 | 166 |
* In a distributed environment there is no guarantee that two VM share |
2 | 167 |
* the same default encoding. Thus clients which want to stream platform |
168 |
* encoded text data from the host platform to a Java Print Service instance |
|
169 |
* must explicitly declare the charset and not rely on defaults. |
|
170 |
* <p> |
|
171 |
* The preferred form is the official IANA primary name for an encoding. |
|
172 |
* Applications which stream text data should always specify the charset |
|
173 |
* in the mime type, which necessitates obtaining the encoding of the host |
|
174 |
* platform for data (eg files) stored in that platform's encoding. |
|
175 |
* A CharSet which corresponds to this and is suitable for use in a |
|
176 |
* mime-type for a DocFlavor can be obtained |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
177 |
* from {@link DocFlavor#hostEncoding DocFlavor.hostEncoding} |
2 | 178 |
* This may not always be the primary IANA name but is guaranteed to be |
179 |
* understood by this VM. |
|
180 |
* For common flavors, the pre-defined *HOST DocFlavors may be used. |
|
181 |
* <p> |
|
182 |
* <p> |
|
183 |
* See <a href="../../java/lang/package-summary.html#charenc"> |
|
184 |
* character encodings</a> for more information on the character encodings |
|
185 |
* supported on the Java platform. |
|
186 |
* <p> |
|
187 |
* <HR> |
|
188 |
* <h3>Recommended DocFlavors</h3> |
|
189 |
* <P> |
|
190 |
* The Java Print Service API does not define any mandatorily supported |
|
191 |
* DocFlavors. |
|
192 |
* However, here are some examples of MIME types that a Java Print Service |
|
193 |
* instance might support for client formatted print data. |
|
194 |
* Nested classes inside class DocFlavor declare predefined static |
|
195 |
* constant DocFlavor objects for these example doc flavors; class DocFlavor's |
|
196 |
* constructor can be used to create an arbitrary doc flavor. |
|
197 |
* <UL> |
|
198 |
* <LI>Preformatted text |
|
199 |
* <P> |
|
200 |
* <TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 SUMMARY="MIME-Types and their descriptions"> |
|
201 |
* <TR> |
|
202 |
* <TH>MIME-Type</TH><TH>Description</TH> |
|
203 |
* </TR> |
|
204 |
* <TR> |
|
205 |
* <TD><CODE>"text/plain"</CODE></TD> |
|
206 |
* <TD>Plain text in the default character set (US-ASCII)</TD> |
|
207 |
* </TR> |
|
208 |
* <TR> |
|
209 |
* <TD><CODE>"text/plain; charset=<I>xxx</I>"</CODE></TD> |
|
210 |
* <TD>Plain text in character set <I>xxx</I></TD> |
|
211 |
* </TR> |
|
212 |
* <TR> |
|
213 |
* <TD><CODE>"text/html"</CODE></TD> |
|
214 |
* <TD>HyperText Markup Language in the default character set (US-ASCII)</TD> |
|
215 |
* </TR> |
|
216 |
* <TR> |
|
217 |
* <TD><CODE>"text/html; charset=<I>xxx</I>"</CODE></TD> |
|
218 |
* <TD>HyperText Markup Language in character set <I>xxx</I></TD> |
|
219 |
* </TR> |
|
220 |
* </TABLE> |
|
221 |
* <P> |
|
222 |
* In general, preformatted text print data is provided either in a character |
|
223 |
* oriented representation class (character array, String, Reader) or in a |
|
224 |
* byte oriented representation class (byte array, InputStream, URL). |
|
225 |
* <P> |
|
226 |
* <LI>Preformatted page description language (PDL) documents |
|
227 |
*<P> |
|
228 |
* <TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 SUMMARY="MIME-Types and their descriptions"> |
|
229 |
* <TR> |
|
230 |
* <TH>MIME-Type</TH><TH>Description</TH> |
|
231 |
* </TR> |
|
232 |
*<TR> |
|
233 |
* <TD><CODE>"application/pdf"</CODE></TD> |
|
234 |
* <TD>Portable Document Format document</TD> |
|
235 |
* </TR> |
|
236 |
* <TR> |
|
237 |
* <TD><CODE>"application/postscript"</CODE></TD> |
|
238 |
* <TD>PostScript document</TD> |
|
239 |
* </TR> |
|
240 |
* <TR> |
|
241 |
* <TD><CODE>"application/vnd.hp-PCL"</CODE></TD> |
|
242 |
* <TD>Printer Control Language document</TD> |
|
243 |
* </TR> |
|
244 |
* </TABLE> |
|
245 |
* <P> |
|
246 |
* In general, preformatted PDL print data is provided in a byte oriented |
|
247 |
* representation class (byte array, InputStream, URL). |
|
248 |
* <P> |
|
249 |
* <LI>Preformatted images |
|
250 |
*<P> |
|
251 |
* <TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 SUMMARY="MIME-Types and their descriptions"> |
|
252 |
* <TR> |
|
253 |
* <TH>MIME-Type</TH><TH>Description</TH> |
|
254 |
* </TR> |
|
255 |
* |
|
256 |
* <TR> |
|
257 |
* <TD><CODE>"image/gif"</CODE></TD> |
|
258 |
* <TD>Graphics Interchange Format image</TD> |
|
259 |
* </TR> |
|
260 |
* <TR> |
|
261 |
* <TD><CODE>"image/jpeg"</CODE></TD> |
|
262 |
* <TD>Joint Photographic Experts Group image</TD> |
|
263 |
* </TR> |
|
264 |
* <TR> |
|
265 |
* <TD><CODE>"image/png"</CODE></TD> |
|
266 |
* <TD>Portable Network Graphics image</TD> |
|
267 |
* </TR> |
|
268 |
* </TABLE> |
|
269 |
* <P> |
|
270 |
* In general, preformatted image print data is provided in a byte oriented |
|
271 |
* representation class (byte array, InputStream, URL). |
|
272 |
* <P> |
|
273 |
* <LI>Preformatted autosense print data |
|
274 |
* <P> |
|
275 |
* <TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 SUMMARY="MIME-Types and their descriptions"> |
|
276 |
* <TR> |
|
277 |
* <TH>MIME-Type</TH><TH>Description</TH> |
|
278 |
* </TR> |
|
279 |
* |
|
280 |
* <TR> |
|
281 |
* <TD><CODE>"application/octet-stream"</CODE></TD> |
|
282 |
* <TD>The print data format is unspecified (just an octet stream)</TD> |
|
283 |
* </TABLE> |
|
284 |
* <P> |
|
285 |
* The printer decides how to interpret the print data; the way this |
|
286 |
* "autosensing" works is implementation dependent. In general, preformatted |
|
287 |
* autosense print data is provided in a byte oriented representation class |
|
288 |
* (byte array, InputStream, URL). |
|
19166 | 289 |
* </UL> |
2 | 290 |
* <P> |
291 |
* <HR> |
|
292 |
* <H3>Service Formatted Print Data</H3> |
|
293 |
* <P> |
|
294 |
* For <B>service formatted print data</B>, the Java Print Service instance |
|
295 |
* determines the print data format. The doc flavor's representation class |
|
296 |
* denotes an interface whose methods the <code>DocPrintJob</code> invokes to |
|
297 |
* determine the content to be printed -- such as a renderable image |
|
298 |
* interface or a Java printable interface. |
|
299 |
* The doc flavor's MIME type is the special value |
|
300 |
* <CODE>"application/x-java-jvm-local-objectref"</CODE> indicating the client |
|
301 |
* will supply a reference to a Java object that implements the interface |
|
302 |
* named as the representation class. |
|
303 |
* This MIME type is just a placeholder; what's |
|
304 |
* important is the print data representation class. |
|
305 |
* <P> |
|
306 |
* For service formatted print data, the print data representation class is |
|
307 |
* typically one of the following (although other representation classes are |
|
308 |
* permitted). Nested classes inside class DocFlavor declare predefined static |
|
309 |
* constant DocFlavor objects for these example doc flavors; class DocFlavor's |
|
310 |
* constructor can be used to create an arbitrary doc flavor. |
|
311 |
* <UL> |
|
312 |
* <LI> |
|
313 |
* Renderable image object -- The client supplies an object that implements |
|
314 |
* interface |
|
315 |
* {@link java.awt.image.renderable.RenderableImage RenderableImage}. The |
|
316 |
* printer calls methods |
|
317 |
* in that interface to obtain the image to be printed. |
|
318 |
* <P> |
|
319 |
* <LI> |
|
320 |
* Printable object -- The client supplies an object that implements interface |
|
321 |
* {@link java.awt.print.Printable Printable}. |
|
322 |
* The printer calls methods in that interface to obtain the pages to be |
|
323 |
* printed, one by one. |
|
324 |
* For each page, the printer supplies a graphics context, and whatever the |
|
325 |
* client draws in that graphics context gets printed. |
|
326 |
* <P> |
|
327 |
* <LI> |
|
328 |
* Pageable object -- The client supplies an object that implements interface |
|
329 |
* {@link java.awt.print.Pageable Pageable}. The printer calls |
|
330 |
* methods in that interface to obtain the pages to be printed, one by one. |
|
331 |
* For each page, the printer supplies a graphics context, and whatever |
|
332 |
* the client draws in that graphics context gets printed. |
|
333 |
* </UL> |
|
334 |
* <P> |
|
335 |
* <HR> |
|
336 |
* <P> |
|
337 |
* <HR> |
|
338 |
* <H3>Pre-defined Doc Flavors</H3> |
|
339 |
* A Java Print Service instance is not <B><I>required</I></B> to support the |
|
340 |
* following print data formats and print data representation classes. In |
|
341 |
* fact, a developer using this class should <b>never</b> assume that a |
|
342 |
* particular print service supports the document types corresponding to |
|
343 |
* these pre-defined doc flavors. Always query the print service |
|
344 |
* to determine what doc flavors it supports. However, |
|
345 |
* developers who have print services that support these doc flavors are |
|
346 |
* encouraged to refer to the predefined singleton instances created here. |
|
347 |
* <UL> |
|
348 |
* <LI> |
|
349 |
* Plain text print data provided through a byte stream. Specifically, the |
|
350 |
* following doc flavors are recommended to be supported: |
|
351 |
* <BR>· |
|
352 |
* <CODE>("text/plain", "java.io.InputStream")</CODE> |
|
353 |
* <BR>· |
|
354 |
* <CODE>("text/plain; charset=us-ascii", "java.io.InputStream")</CODE> |
|
355 |
* <BR>· |
|
356 |
* <CODE>("text/plain; charset=utf-8", "java.io.InputStream")</CODE> |
|
357 |
* <P> |
|
358 |
* <LI> |
|
359 |
* Renderable image objects. Specifically, the following doc flavor is |
|
360 |
* recommended to be supported: |
|
361 |
* <BR>· |
|
362 |
* <CODE>("application/x-java-jvm-local-objectref", "java.awt.image.renderable.RenderableImage")</CODE> |
|
363 |
* </UL> |
|
364 |
* <P> |
|
365 |
* A Java Print Service instance is allowed to support any other doc flavors |
|
366 |
* (or none) in addition to the above mandatory ones, at the implementation's |
|
367 |
* choice. |
|
368 |
* <P> |
|
369 |
* Support for the above doc flavors is desirable so a printing client can rely |
|
370 |
* on being able to print on any JPS printer, regardless of which doc flavors |
|
371 |
* the printer supports. If the printer doesn't support the client's preferred |
|
372 |
* doc flavor, the client can at least print plain text, or the client can |
|
373 |
* convert its data to a renderable image and print the image. |
|
374 |
* <P> |
|
375 |
* Furthermore, every Java Print Service instance must fulfill these |
|
376 |
* requirements for processing plain text print data: |
|
377 |
* <UL> |
|
378 |
* <LI> |
|
379 |
* The character pair carriage return-line feed (CR-LF) means |
|
380 |
* "go to column 1 of the next line." |
|
381 |
* <LI> |
|
382 |
* A carriage return (CR) character standing by itself means |
|
383 |
* "go to column 1 of the next line." |
|
384 |
* <LI> |
|
385 |
* A line feed (LF) character standing by itself means |
|
386 |
* "go to column 1 of the next line." |
|
387 |
* <LI> |
|
388 |
* </UL> |
|
389 |
* <P> |
|
390 |
* The client must itself perform all plain text print data formatting not |
|
391 |
* addressed by the above requirements. |
|
392 |
* <P> |
|
393 |
* <H3>Design Rationale</H3> |
|
394 |
* <P> |
|
395 |
* Class DocFlavor in package javax.print.data is similar to class |
|
396 |
* {@link java.awt.datatransfer.DataFlavor DataFlavor}. Class |
|
397 |
* <code>DataFlavor</code> |
|
398 |
* is not used in the Java Print Service (JPS) API |
|
399 |
* for three reasons which are all rooted in allowing the JPS API to be |
|
400 |
* shared by other print services APIs which may need to run on Java profiles |
|
401 |
* which do not include all of the Java Platform, Standard Edition. |
|
402 |
* <OL TYPE=1> |
|
403 |
* <LI> |
|
404 |
* The JPS API is designed to be used in Java profiles which do not support |
|
405 |
* AWT. |
|
406 |
* <P> |
|
407 |
* <LI> |
|
408 |
* The implementation of class <code>java.awt.datatransfer.DataFlavor</code> |
|
409 |
* does not guarantee that equivalent data flavors will have the same |
|
410 |
* serialized representation. DocFlavor does, and can be used in services |
|
411 |
* which need this. |
|
412 |
* <P> |
|
413 |
* <LI> |
|
414 |
* The implementation of class <code>java.awt.datatransfer.DataFlavor</code> |
|
415 |
* includes a human presentable name as part of the serialized representation. |
|
416 |
* This is not appropriate as part of a service matching constraint. |
|
417 |
* </OL> |
|
418 |
* <P> |
|
419 |
* Class DocFlavor's serialized representation uses the following |
|
420 |
* canonical form of a MIME type string. Thus, two doc flavors with MIME types |
|
421 |
* that are not identical but that are equivalent (that have the same |
|
422 |
* canonical form) may be considered equal. |
|
423 |
* <UL> |
|
424 |
* <LI> The media type, media subtype, and parameters are retained, but all |
|
425 |
* comments and whitespace characters are discarded. |
|
426 |
* <LI> The media type, media subtype, and parameter names are converted to |
|
427 |
* lowercase. |
|
428 |
* <LI> The parameter values retain their original case, except a charset |
|
429 |
* parameter value for a text media type is converted to lowercase. |
|
430 |
* <LI> Quote characters surrounding parameter values are removed. |
|
431 |
* <LI> Quoting backslash characters inside parameter values are removed. |
|
432 |
* <LI> The parameters are arranged in ascending order of parameter name. |
|
433 |
* </UL> |
|
434 |
* <P> |
|
435 |
* Class DocFlavor's serialized representation also contains the |
|
436 |
* fully-qualified class <I>name</I> of the representation class |
|
437 |
* (a String object), rather than the representation class itself |
|
438 |
* (a Class object). This allows a client to examine the doc flavors a |
|
439 |
* Java Print Service instance supports without having |
|
440 |
* to load the representation classes, which may be problematic for |
|
441 |
* limited-resource clients. |
|
442 |
* <P> |
|
443 |
* |
|
444 |
* @author Alan Kaminsky |
|
445 |
*/ |
|
446 |
public class DocFlavor implements Serializable, Cloneable { |
|
447 |
||
448 |
private static final long serialVersionUID = -4512080796965449721L; |
|
449 |
||
450 |
/** |
|
451 |
* A String representing the host operating system encoding. |
|
452 |
* This will follow the conventions documented in |
|
5820
4f5e99470724
6967036: Need to fix links with // in Javadoc comments
ohair
parents:
5627
diff
changeset
|
453 |
* <a href="http://www.ietf.org/rfc/rfc2278.txt"> |
2 | 454 |
* <i>RFC 2278: IANA Charset Registration Procedures</i></a> |
455 |
* except where historical names are returned for compatibility with |
|
456 |
* previous versions of the Java platform. |
|
457 |
* The value returned from method is valid only for the VM which |
|
458 |
* returns it, for use in a DocFlavor. |
|
459 |
* This is the charset for all the "HOST" pre-defined DocFlavors in |
|
460 |
* the executing VM. |
|
461 |
*/ |
|
462 |
public static final String hostEncoding; |
|
463 |
||
464 |
static { |
|
465 |
hostEncoding = |
|
466 |
(String)java.security.AccessController.doPrivileged( |
|
467 |
new sun.security.action.GetPropertyAction("file.encoding")); |
|
468 |
} |
|
469 |
||
470 |
/** |
|
471 |
* MIME type. |
|
472 |
*/ |
|
473 |
private transient MimeType myMimeType; |
|
474 |
||
475 |
/** |
|
476 |
* Representation class name. |
|
477 |
* @serial |
|
478 |
*/ |
|
479 |
private String myClassName; |
|
480 |
||
481 |
/** |
|
482 |
* String value for this doc flavor. Computed when needed and cached. |
|
483 |
*/ |
|
484 |
private transient String myStringValue = null; |
|
485 |
||
486 |
||
487 |
/** |
|
488 |
* Constructs a new doc flavor object from the given MIME type and |
|
489 |
* representation class name. The given MIME type is converted into |
|
490 |
* canonical form and stored internally. |
|
491 |
* |
|
492 |
* @param mimeType MIME media type string. |
|
493 |
* @param className Fully-qualified representation class name. |
|
494 |
* |
|
495 |
* @exception NullPointerException |
|
496 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null or |
|
497 |
* <CODE>className</CODE> is null. |
|
498 |
* @exception IllegalArgumentException |
|
499 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not |
|
500 |
* obey the syntax for a MIME media type string. |
|
501 |
*/ |
|
502 |
public DocFlavor(String mimeType, String className) { |
|
503 |
if (className == null) { |
|
504 |
throw new NullPointerException(); |
|
505 |
} |
|
506 |
myMimeType = new MimeType (mimeType); |
|
507 |
myClassName = className; |
|
508 |
} |
|
509 |
||
510 |
/** |
|
511 |
* Returns this doc flavor object's MIME type string based on the |
|
512 |
* canonical form. Each parameter value is enclosed in quotes. |
|
513 |
* @return the mime type |
|
514 |
*/ |
|
515 |
public String getMimeType() { |
|
516 |
return myMimeType.getMimeType(); |
|
517 |
} |
|
518 |
||
519 |
/** |
|
520 |
* Returns this doc flavor object's media type (from the MIME type). |
|
521 |
* @return the media type |
|
522 |
*/ |
|
523 |
public String getMediaType() { |
|
524 |
return myMimeType.getMediaType(); |
|
525 |
} |
|
526 |
||
527 |
/** |
|
528 |
* Returns this doc flavor object's media subtype (from the MIME type). |
|
529 |
* @return the media sub-type |
|
530 |
*/ |
|
531 |
public String getMediaSubtype() { |
|
532 |
return myMimeType.getMediaSubtype(); |
|
533 |
} |
|
534 |
||
535 |
/** |
|
536 |
* Returns a <code>String</code> representing a MIME |
|
537 |
* parameter. |
|
538 |
* Mime types may include parameters which are usually optional. |
|
539 |
* The charset for text types is a commonly useful example. |
|
540 |
* This convenience method will return the value of the specified |
|
541 |
* parameter if one was specified in the mime type for this flavor. |
|
542 |
* <p> |
|
543 |
* @param paramName the name of the paramater. This name is internally |
|
544 |
* converted to the canonical lower case format before performing |
|
545 |
* the match. |
|
546 |
* @return String representing a mime parameter, or |
|
547 |
* null if that parameter is not in the mime type string. |
|
19166 | 548 |
* @exception NullPointerException if paramName is null. |
2 | 549 |
*/ |
550 |
public String getParameter(String paramName) { |
|
551 |
return |
|
552 |
(String)myMimeType.getParameterMap().get(paramName.toLowerCase()); |
|
553 |
} |
|
554 |
||
555 |
/** |
|
556 |
* Returns the name of this doc flavor object's representation class. |
|
557 |
* @return the name of the representation class. |
|
558 |
*/ |
|
559 |
public String getRepresentationClassName() { |
|
560 |
return myClassName; |
|
561 |
} |
|
562 |
||
563 |
/** |
|
564 |
* Converts this <code>DocFlavor</code> to a string. |
|
565 |
* |
|
566 |
* @return MIME type string based on the canonical form. Each parameter |
|
567 |
* value is enclosed in quotes. |
|
568 |
* A "class=" parameter is appended to the |
|
569 |
* MIME type string to indicate the representation class name. |
|
570 |
*/ |
|
571 |
public String toString() { |
|
572 |
return getStringValue(); |
|
573 |
} |
|
574 |
||
575 |
/** |
|
576 |
* Returns a hash code for this doc flavor object. |
|
577 |
*/ |
|
578 |
public int hashCode() { |
|
579 |
return getStringValue().hashCode(); |
|
580 |
} |
|
581 |
||
582 |
/** |
|
583 |
* Determines if this doc flavor object is equal to the given object. |
|
584 |
* The two are equal if the given object is not null, is an instance |
|
585 |
* of <code>DocFlavor</code>, has a MIME type equivalent to this doc |
|
586 |
* flavor object's MIME type (that is, the MIME types have the same media |
|
587 |
* type, media subtype, and parameters), and has the same representation |
|
588 |
* class name as this doc flavor object. Thus, if two doc flavor objects' |
|
589 |
* MIME types are the same except for comments, they are considered equal. |
|
590 |
* However, two doc flavor objects with MIME types of "text/plain" and |
|
591 |
* "text/plain; charset=US-ASCII" are not considered equal, even though |
|
592 |
* they represent the same media type (because the default character |
|
593 |
* set for plain text is US-ASCII). |
|
594 |
* |
|
595 |
* @param obj Object to test. |
|
596 |
* |
|
597 |
* @return True if this doc flavor object equals <CODE>obj</CODE>, false |
|
598 |
* otherwise. |
|
599 |
*/ |
|
600 |
public boolean equals(Object obj) { |
|
601 |
return |
|
602 |
obj != null && |
|
603 |
obj instanceof DocFlavor && |
|
604 |
getStringValue().equals (((DocFlavor) obj).getStringValue()); |
|
605 |
} |
|
606 |
||
607 |
/** |
|
608 |
* Returns this doc flavor object's string value. |
|
609 |
*/ |
|
610 |
private String getStringValue() { |
|
611 |
if (myStringValue == null) { |
|
612 |
myStringValue = myMimeType + "; class=\"" + myClassName + "\""; |
|
613 |
} |
|
614 |
return myStringValue; |
|
615 |
} |
|
616 |
||
617 |
/** |
|
618 |
* Write the instance to a stream (ie serialize the object). |
|
619 |
*/ |
|
620 |
private void writeObject(ObjectOutputStream s) throws IOException { |
|
621 |
||
622 |
s.defaultWriteObject(); |
|
623 |
s.writeObject(myMimeType.getMimeType()); |
|
624 |
} |
|
625 |
||
626 |
/** |
|
627 |
* Reconstitute an instance from a stream (that is, deserialize it). |
|
628 |
* |
|
629 |
* @serialData |
|
630 |
* The serialised form of a DocFlavor is the String naming the |
|
631 |
* representation class followed by the String representing the canonical |
|
632 |
* form of the mime type. |
|
633 |
*/ |
|
634 |
private void readObject(ObjectInputStream s) |
|
635 |
throws ClassNotFoundException, IOException { |
|
636 |
||
637 |
s.defaultReadObject(); |
|
638 |
myMimeType = new MimeType((String)s.readObject()); |
|
639 |
} |
|
640 |
||
641 |
/** |
|
642 |
* Class DocFlavor.BYTE_ARRAY provides predefined static constant |
|
643 |
* DocFlavor objects for example doc flavors using a byte array |
|
644 |
* (<CODE>byte[]</CODE>) as the print data representation class. |
|
645 |
* <P> |
|
646 |
* |
|
647 |
* @author Alan Kaminsky |
|
648 |
*/ |
|
649 |
public static class BYTE_ARRAY extends DocFlavor { |
|
650 |
||
651 |
private static final long serialVersionUID = -9065578006593857475L; |
|
652 |
||
653 |
/** |
|
654 |
* Constructs a new doc flavor with the given MIME type and a print |
|
655 |
* data representation class name of <CODE>"[B"</CODE> (byte array). |
|
656 |
* |
|
657 |
* @param mimeType MIME media type string. |
|
658 |
* |
|
659 |
* @exception NullPointerException |
|
660 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null. |
|
661 |
* @exception IllegalArgumentException |
|
662 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not |
|
663 |
* obey the syntax for a MIME media type string. |
|
664 |
*/ |
|
665 |
public BYTE_ARRAY (String mimeType) { |
|
666 |
super (mimeType, "[B"); |
|
667 |
} |
|
668 |
||
669 |
/** |
|
670 |
* Doc flavor with MIME type = <CODE>"text/plain"</CODE>, |
|
671 |
* encoded in the host platform encoding. |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
672 |
* See {@link DocFlavor#hostEncoding hostEncoding} |
2 | 673 |
* Print data representation class name = |
674 |
* <CODE>"[B"</CODE> (byte array). |
|
675 |
*/ |
|
676 |
public static final BYTE_ARRAY TEXT_PLAIN_HOST = |
|
677 |
new BYTE_ARRAY ("text/plain; charset="+hostEncoding); |
|
678 |
||
679 |
/** |
|
680 |
* Doc flavor with MIME type = |
|
681 |
* <CODE>"text/plain; charset=utf-8"</CODE>, |
|
682 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
683 |
* array). |
|
684 |
*/ |
|
685 |
public static final BYTE_ARRAY TEXT_PLAIN_UTF_8 = |
|
686 |
new BYTE_ARRAY ("text/plain; charset=utf-8"); |
|
687 |
||
688 |
/** |
|
689 |
* Doc flavor with MIME type = |
|
690 |
* <CODE>"text/plain; charset=utf-16"</CODE>, |
|
691 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
692 |
* array). |
|
693 |
*/ |
|
694 |
public static final BYTE_ARRAY TEXT_PLAIN_UTF_16 = |
|
695 |
new BYTE_ARRAY ("text/plain; charset=utf-16"); |
|
696 |
||
697 |
||
698 |
/** |
|
699 |
* Doc flavor with MIME type = |
|
700 |
* <CODE>"text/plain; charset=utf-16be"</CODE> |
|
701 |
* (big-endian byte ordering), |
|
702 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
703 |
* array). |
|
704 |
*/ |
|
705 |
public static final BYTE_ARRAY TEXT_PLAIN_UTF_16BE = |
|
706 |
new BYTE_ARRAY ("text/plain; charset=utf-16be"); |
|
707 |
||
708 |
/** |
|
709 |
* Doc flavor with MIME type = |
|
710 |
* <CODE>"text/plain; charset=utf-16le"</CODE> |
|
711 |
* (little-endian byte ordering), |
|
712 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
713 |
* array). |
|
714 |
*/ |
|
715 |
public static final BYTE_ARRAY TEXT_PLAIN_UTF_16LE = |
|
716 |
new BYTE_ARRAY ("text/plain; charset=utf-16le"); |
|
717 |
||
718 |
/** |
|
719 |
* Doc flavor with MIME type = |
|
720 |
* <CODE>"text/plain; charset=us-ascii"</CODE>, |
|
721 |
* print data representation class name = |
|
722 |
* <CODE>"[B"</CODE> (byte array). |
|
723 |
*/ |
|
724 |
public static final BYTE_ARRAY TEXT_PLAIN_US_ASCII = |
|
725 |
new BYTE_ARRAY ("text/plain; charset=us-ascii"); |
|
726 |
||
727 |
||
728 |
/** |
|
729 |
* Doc flavor with MIME type = <CODE>"text/html"</CODE>, |
|
730 |
* encoded in the host platform encoding. |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
731 |
* See {@link DocFlavor#hostEncoding hostEncoding} |
2 | 732 |
* Print data representation class name = |
733 |
* <CODE>"[B"</CODE> (byte array). |
|
734 |
*/ |
|
735 |
public static final BYTE_ARRAY TEXT_HTML_HOST = |
|
736 |
new BYTE_ARRAY ("text/html; charset="+hostEncoding); |
|
737 |
||
738 |
/** |
|
739 |
* Doc flavor with MIME type = |
|
740 |
* <CODE>"text/html; charset=utf-8"</CODE>, |
|
741 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
742 |
* array). |
|
743 |
*/ |
|
744 |
public static final BYTE_ARRAY TEXT_HTML_UTF_8 = |
|
745 |
new BYTE_ARRAY ("text/html; charset=utf-8"); |
|
746 |
||
747 |
/** |
|
748 |
* Doc flavor with MIME type = |
|
749 |
* <CODE>"text/html; charset=utf-16"</CODE>, |
|
750 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
751 |
* array). |
|
752 |
*/ |
|
753 |
public static final BYTE_ARRAY TEXT_HTML_UTF_16 = |
|
754 |
new BYTE_ARRAY ("text/html; charset=utf-16"); |
|
755 |
||
756 |
/** |
|
757 |
* Doc flavor with MIME type = |
|
758 |
* <CODE>"text/html; charset=utf-16be"</CODE> |
|
759 |
* (big-endian byte ordering), |
|
760 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
761 |
* array). |
|
762 |
*/ |
|
763 |
public static final BYTE_ARRAY TEXT_HTML_UTF_16BE = |
|
764 |
new BYTE_ARRAY ("text/html; charset=utf-16be"); |
|
765 |
||
766 |
/** |
|
767 |
* Doc flavor with MIME type = |
|
768 |
* <CODE>"text/html; charset=utf-16le"</CODE> |
|
769 |
* (little-endian byte ordering), |
|
770 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
771 |
* array). |
|
772 |
*/ |
|
773 |
public static final BYTE_ARRAY TEXT_HTML_UTF_16LE = |
|
774 |
new BYTE_ARRAY ("text/html; charset=utf-16le"); |
|
775 |
||
776 |
/** |
|
777 |
* Doc flavor with MIME type = |
|
778 |
* <CODE>"text/html; charset=us-ascii"</CODE>, |
|
779 |
* print data representation class name = |
|
780 |
* <CODE>"[B"</CODE> (byte array). |
|
781 |
*/ |
|
782 |
public static final BYTE_ARRAY TEXT_HTML_US_ASCII = |
|
783 |
new BYTE_ARRAY ("text/html; charset=us-ascii"); |
|
784 |
||
785 |
||
786 |
/** |
|
787 |
* Doc flavor with MIME type = <CODE>"application/pdf"</CODE>, print |
|
788 |
* data representation class name = <CODE>"[B"</CODE> (byte array). |
|
789 |
*/ |
|
790 |
public static final BYTE_ARRAY PDF = new BYTE_ARRAY ("application/pdf"); |
|
791 |
||
792 |
/** |
|
793 |
* Doc flavor with MIME type = <CODE>"application/postscript"</CODE>, |
|
794 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
795 |
* array). |
|
796 |
*/ |
|
797 |
public static final BYTE_ARRAY POSTSCRIPT = |
|
798 |
new BYTE_ARRAY ("application/postscript"); |
|
799 |
||
800 |
/** |
|
801 |
* Doc flavor with MIME type = <CODE>"application/vnd.hp-PCL"</CODE>, |
|
802 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
803 |
* array). |
|
804 |
*/ |
|
805 |
public static final BYTE_ARRAY PCL = |
|
806 |
new BYTE_ARRAY ("application/vnd.hp-PCL"); |
|
807 |
||
808 |
/** |
|
809 |
* Doc flavor with MIME type = <CODE>"image/gif"</CODE>, print data |
|
810 |
* representation class name = <CODE>"[B"</CODE> (byte array). |
|
811 |
*/ |
|
812 |
public static final BYTE_ARRAY GIF = new BYTE_ARRAY ("image/gif"); |
|
813 |
||
814 |
/** |
|
815 |
* Doc flavor with MIME type = <CODE>"image/jpeg"</CODE>, print data |
|
816 |
* representation class name = <CODE>"[B"</CODE> (byte array). |
|
817 |
*/ |
|
818 |
public static final BYTE_ARRAY JPEG = new BYTE_ARRAY ("image/jpeg"); |
|
819 |
||
820 |
/** |
|
821 |
* Doc flavor with MIME type = <CODE>"image/png"</CODE>, print data |
|
822 |
* representation class name = <CODE>"[B"</CODE> (byte array). |
|
823 |
*/ |
|
824 |
public static final BYTE_ARRAY PNG = new BYTE_ARRAY ("image/png"); |
|
825 |
||
826 |
/** |
|
827 |
* Doc flavor with MIME type = |
|
828 |
* <CODE>"application/octet-stream"</CODE>, |
|
829 |
* print data representation class name = <CODE>"[B"</CODE> (byte |
|
830 |
* array). The client must determine that data described |
|
831 |
* using this DocFlavor is valid for the printer. |
|
832 |
*/ |
|
833 |
public static final BYTE_ARRAY AUTOSENSE = |
|
834 |
new BYTE_ARRAY ("application/octet-stream"); |
|
835 |
||
836 |
} |
|
837 |
||
838 |
/** |
|
839 |
* Class DocFlavor.INPUT_STREAM provides predefined static constant |
|
840 |
* DocFlavor objects for example doc flavors using a byte stream ({@link |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
841 |
* java.io.InputStream java.io.InputStream}) as the print |
2 | 842 |
* data representation class. |
843 |
* <P> |
|
844 |
* |
|
845 |
* @author Alan Kaminsky |
|
846 |
*/ |
|
847 |
public static class INPUT_STREAM extends DocFlavor { |
|
848 |
||
849 |
private static final long serialVersionUID = -7045842700749194127L; |
|
850 |
||
851 |
/** |
|
852 |
* Constructs a new doc flavor with the given MIME type and a print |
|
853 |
* data representation class name of |
|
854 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
855 |
* |
|
856 |
* @param mimeType MIME media type string. |
|
857 |
* |
|
858 |
* @exception NullPointerException |
|
859 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null. |
|
860 |
* @exception IllegalArgumentException |
|
861 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not |
|
862 |
* obey the syntax for a MIME media type string. |
|
863 |
*/ |
|
864 |
public INPUT_STREAM (String mimeType) { |
|
865 |
super (mimeType, "java.io.InputStream"); |
|
866 |
} |
|
867 |
||
868 |
/** |
|
869 |
* Doc flavor with MIME type = <CODE>"text/plain"</CODE>, |
|
870 |
* encoded in the host platform encoding. |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
871 |
* See {@link DocFlavor#hostEncoding hostEncoding} |
2 | 872 |
* Print data representation class name = |
873 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
874 |
*/ |
|
875 |
public static final INPUT_STREAM TEXT_PLAIN_HOST = |
|
876 |
new INPUT_STREAM ("text/plain; charset="+hostEncoding); |
|
877 |
||
878 |
/** |
|
879 |
* Doc flavor with MIME type = |
|
880 |
* <CODE>"text/plain; charset=utf-8"</CODE>, |
|
881 |
* print data representation class name = |
|
882 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
883 |
*/ |
|
884 |
public static final INPUT_STREAM TEXT_PLAIN_UTF_8 = |
|
885 |
new INPUT_STREAM ("text/plain; charset=utf-8"); |
|
886 |
||
887 |
/** |
|
888 |
* Doc flavor with MIME type = |
|
889 |
* <CODE>"text/plain; charset=utf-16"</CODE>, |
|
890 |
* print data representation class name = |
|
891 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
892 |
*/ |
|
893 |
public static final INPUT_STREAM TEXT_PLAIN_UTF_16 = |
|
894 |
new INPUT_STREAM ("text/plain; charset=utf-16"); |
|
895 |
||
896 |
/** |
|
897 |
* Doc flavor with MIME type = |
|
898 |
* <CODE>"text/plain; charset=utf-16be"</CODE> |
|
899 |
* (big-endian byte ordering), |
|
900 |
* print data representation class name = |
|
901 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
902 |
*/ |
|
903 |
public static final INPUT_STREAM TEXT_PLAIN_UTF_16BE = |
|
904 |
new INPUT_STREAM ("text/plain; charset=utf-16be"); |
|
905 |
||
906 |
/** |
|
907 |
* Doc flavor with MIME type = |
|
908 |
* <CODE>"text/plain; charset=utf-16le"</CODE> |
|
909 |
* (little-endian byte ordering), |
|
910 |
* print data representation class name = |
|
911 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
912 |
*/ |
|
913 |
public static final INPUT_STREAM TEXT_PLAIN_UTF_16LE = |
|
914 |
new INPUT_STREAM ("text/plain; charset=utf-16le"); |
|
915 |
||
916 |
/** |
|
917 |
* Doc flavor with MIME type = |
|
918 |
* <CODE>"text/plain; charset=us-ascii"</CODE>, |
|
919 |
* print data representation class name = |
|
920 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
921 |
*/ |
|
922 |
public static final INPUT_STREAM TEXT_PLAIN_US_ASCII = |
|
923 |
new INPUT_STREAM ("text/plain; charset=us-ascii"); |
|
924 |
||
925 |
/** |
|
926 |
* Doc flavor with MIME type = <CODE>"text/html"</CODE>, |
|
927 |
* encoded in the host platform encoding. |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
928 |
* See {@link DocFlavor#hostEncoding hostEncoding} |
2 | 929 |
* Print data representation class name = |
930 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
931 |
*/ |
|
932 |
public static final INPUT_STREAM TEXT_HTML_HOST = |
|
933 |
new INPUT_STREAM ("text/html; charset="+hostEncoding); |
|
934 |
||
935 |
/** |
|
936 |
* Doc flavor with MIME type = |
|
937 |
* <CODE>"text/html; charset=utf-8"</CODE>, |
|
938 |
* print data representation class name = |
|
939 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
940 |
*/ |
|
941 |
public static final INPUT_STREAM TEXT_HTML_UTF_8 = |
|
942 |
new INPUT_STREAM ("text/html; charset=utf-8"); |
|
943 |
||
944 |
/** |
|
945 |
* Doc flavor with MIME type = |
|
946 |
* <CODE>"text/html; charset=utf-16"</CODE>, |
|
947 |
* print data representation class name = |
|
948 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
949 |
*/ |
|
950 |
public static final INPUT_STREAM TEXT_HTML_UTF_16 = |
|
951 |
new INPUT_STREAM ("text/html; charset=utf-16"); |
|
952 |
||
953 |
/** |
|
954 |
* Doc flavor with MIME type = |
|
955 |
* <CODE>"text/html; charset=utf-16be"</CODE> |
|
956 |
* (big-endian byte ordering), |
|
957 |
* print data representation class name = |
|
958 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
959 |
*/ |
|
960 |
public static final INPUT_STREAM TEXT_HTML_UTF_16BE = |
|
961 |
new INPUT_STREAM ("text/html; charset=utf-16be"); |
|
962 |
||
963 |
/** |
|
964 |
* Doc flavor with MIME type = |
|
965 |
* <CODE>"text/html; charset=utf-16le"</CODE> |
|
966 |
* (little-endian byte ordering), |
|
967 |
* print data representation class name = |
|
968 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
969 |
*/ |
|
970 |
public static final INPUT_STREAM TEXT_HTML_UTF_16LE = |
|
971 |
new INPUT_STREAM ("text/html; charset=utf-16le"); |
|
972 |
||
973 |
/** |
|
974 |
* Doc flavor with MIME type = |
|
975 |
* <CODE>"text/html; charset=us-ascii"</CODE>, |
|
976 |
* print data representation class name = |
|
977 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
978 |
*/ |
|
979 |
public static final INPUT_STREAM TEXT_HTML_US_ASCII = |
|
980 |
new INPUT_STREAM ("text/html; charset=us-ascii"); |
|
981 |
||
982 |
||
983 |
/** |
|
984 |
* Doc flavor with MIME type = <CODE>"application/pdf"</CODE>, print |
|
985 |
* data representation class name = <CODE>"java.io.InputStream"</CODE> |
|
986 |
* (byte stream). |
|
987 |
*/ |
|
988 |
public static final INPUT_STREAM PDF = new INPUT_STREAM ("application/pdf"); |
|
989 |
||
990 |
/** |
|
991 |
* Doc flavor with MIME type = <CODE>"application/postscript"</CODE>, |
|
992 |
* print data representation class name = |
|
993 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
994 |
*/ |
|
995 |
public static final INPUT_STREAM POSTSCRIPT = |
|
996 |
new INPUT_STREAM ("application/postscript"); |
|
997 |
||
998 |
/** |
|
999 |
* Doc flavor with MIME type = <CODE>"application/vnd.hp-PCL"</CODE>, |
|
1000 |
* print data representation class name = |
|
1001 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
1002 |
*/ |
|
1003 |
public static final INPUT_STREAM PCL = |
|
1004 |
new INPUT_STREAM ("application/vnd.hp-PCL"); |
|
1005 |
||
1006 |
/** |
|
1007 |
* Doc flavor with MIME type = <CODE>"image/gif"</CODE>, print data |
|
1008 |
* representation class name = |
|
1009 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
1010 |
*/ |
|
1011 |
public static final INPUT_STREAM GIF = new INPUT_STREAM ("image/gif"); |
|
1012 |
||
1013 |
/** |
|
1014 |
* Doc flavor with MIME type = <CODE>"image/jpeg"</CODE>, print data |
|
1015 |
* representation class name = |
|
1016 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
1017 |
*/ |
|
1018 |
public static final INPUT_STREAM JPEG = new INPUT_STREAM ("image/jpeg"); |
|
1019 |
||
1020 |
/** |
|
1021 |
* Doc flavor with MIME type = <CODE>"image/png"</CODE>, print data |
|
1022 |
* representation class name = |
|
1023 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
1024 |
*/ |
|
1025 |
public static final INPUT_STREAM PNG = new INPUT_STREAM ("image/png"); |
|
1026 |
||
1027 |
/** |
|
1028 |
* Doc flavor with MIME type = |
|
1029 |
* <CODE>"application/octet-stream"</CODE>, |
|
1030 |
* print data representation class name = |
|
1031 |
* <CODE>"java.io.InputStream"</CODE> (byte stream). |
|
1032 |
* The client must determine that data described |
|
1033 |
* using this DocFlavor is valid for the printer. |
|
1034 |
*/ |
|
1035 |
public static final INPUT_STREAM AUTOSENSE = |
|
1036 |
new INPUT_STREAM ("application/octet-stream"); |
|
1037 |
||
1038 |
} |
|
1039 |
||
1040 |
/** |
|
1041 |
* Class DocFlavor.URL provides predefined static constant DocFlavor |
|
1042 |
* objects. |
|
1043 |
* For example doc flavors using a Uniform Resource Locator ({@link |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
1044 |
* java.net.URL java.net.URL}) as the print data |
2 | 1045 |
* representation class. |
1046 |
* <P> |
|
1047 |
* |
|
1048 |
* @author Alan Kaminsky |
|
1049 |
*/ |
|
1050 |
public static class URL extends DocFlavor { |
|
1051 |
||
1052 |
/** |
|
1053 |
* Constructs a new doc flavor with the given MIME type and a print |
|
1054 |
* data representation class name of <CODE>"java.net.URL"</CODE>. |
|
1055 |
* |
|
1056 |
* @param mimeType MIME media type string. |
|
1057 |
* |
|
1058 |
* @exception NullPointerException |
|
1059 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null. |
|
1060 |
* @exception IllegalArgumentException |
|
1061 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not |
|
1062 |
* obey the syntax for a MIME media type string. |
|
1063 |
*/ |
|
1064 |
public URL (String mimeType) { |
|
1065 |
super (mimeType, "java.net.URL"); |
|
1066 |
} |
|
1067 |
||
1068 |
/** |
|
1069 |
* Doc flavor with MIME type = <CODE>"text/plain"</CODE>, |
|
1070 |
* encoded in the host platform encoding. |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
1071 |
* See {@link DocFlavor#hostEncoding hostEncoding} |
2 | 1072 |
* Print data representation class name = |
1073 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1074 |
*/ |
|
1075 |
public static final URL TEXT_PLAIN_HOST = |
|
1076 |
new URL ("text/plain; charset="+hostEncoding); |
|
1077 |
||
1078 |
/** |
|
1079 |
* Doc flavor with MIME type = |
|
1080 |
* <CODE>"text/plain; charset=utf-8"</CODE>, |
|
1081 |
* print data representation class name = |
|
1082 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1083 |
*/ |
|
1084 |
public static final URL TEXT_PLAIN_UTF_8 = |
|
1085 |
new URL ("text/plain; charset=utf-8"); |
|
1086 |
||
1087 |
/** |
|
1088 |
* Doc flavor with MIME type = |
|
1089 |
* <CODE>"text/plain; charset=utf-16"</CODE>, |
|
1090 |
* print data representation class name = |
|
1091 |
* <CODE>java.net.URL""</CODE> (byte stream). |
|
1092 |
*/ |
|
1093 |
public static final URL TEXT_PLAIN_UTF_16 = |
|
1094 |
new URL ("text/plain; charset=utf-16"); |
|
1095 |
||
1096 |
/** |
|
1097 |
* Doc flavor with MIME type = |
|
1098 |
* <CODE>"text/plain; charset=utf-16be"</CODE> |
|
1099 |
* (big-endian byte ordering), |
|
1100 |
* print data representation class name = |
|
1101 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1102 |
*/ |
|
1103 |
public static final URL TEXT_PLAIN_UTF_16BE = |
|
1104 |
new URL ("text/plain; charset=utf-16be"); |
|
1105 |
||
1106 |
/** |
|
1107 |
* Doc flavor with MIME type = |
|
1108 |
* <CODE>"text/plain; charset=utf-16le"</CODE> |
|
1109 |
* (little-endian byte ordering), |
|
1110 |
* print data representation class name = |
|
1111 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1112 |
*/ |
|
1113 |
public static final URL TEXT_PLAIN_UTF_16LE = |
|
1114 |
new URL ("text/plain; charset=utf-16le"); |
|
1115 |
||
1116 |
/** |
|
1117 |
* Doc flavor with MIME type = |
|
1118 |
* <CODE>"text/plain; charset=us-ascii"</CODE>, |
|
1119 |
* print data representation class name = |
|
1120 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1121 |
*/ |
|
1122 |
public static final URL TEXT_PLAIN_US_ASCII = |
|
1123 |
new URL ("text/plain; charset=us-ascii"); |
|
1124 |
||
1125 |
/** |
|
1126 |
* Doc flavor with MIME type = <CODE>"text/html"</CODE>, |
|
1127 |
* encoded in the host platform encoding. |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
1128 |
* See {@link DocFlavor#hostEncoding hostEncoding} |
2 | 1129 |
* Print data representation class name = |
1130 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1131 |
*/ |
|
1132 |
public static final URL TEXT_HTML_HOST = |
|
1133 |
new URL ("text/html; charset="+hostEncoding); |
|
1134 |
||
1135 |
/** |
|
1136 |
* Doc flavor with MIME type = |
|
1137 |
* <CODE>"text/html; charset=utf-8"</CODE>, |
|
1138 |
* print data representation class name = |
|
1139 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1140 |
*/ |
|
1141 |
public static final URL TEXT_HTML_UTF_8 = |
|
1142 |
new URL ("text/html; charset=utf-8"); |
|
1143 |
||
1144 |
/** |
|
1145 |
* Doc flavor with MIME type = |
|
1146 |
* <CODE>"text/html; charset=utf-16"</CODE>, |
|
1147 |
* print data representation class name = |
|
1148 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1149 |
*/ |
|
1150 |
public static final URL TEXT_HTML_UTF_16 = |
|
1151 |
new URL ("text/html; charset=utf-16"); |
|
1152 |
||
1153 |
/** |
|
1154 |
* Doc flavor with MIME type = |
|
1155 |
* <CODE>"text/html; charset=utf-16be"</CODE> |
|
1156 |
* (big-endian byte ordering), |
|
1157 |
* print data representation class name = |
|
1158 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1159 |
*/ |
|
1160 |
public static final URL TEXT_HTML_UTF_16BE = |
|
1161 |
new URL ("text/html; charset=utf-16be"); |
|
1162 |
||
1163 |
/** |
|
1164 |
* Doc flavor with MIME type = |
|
1165 |
* <CODE>"text/html; charset=utf-16le"</CODE> |
|
1166 |
* (little-endian byte ordering), |
|
1167 |
* print data representation class name = |
|
1168 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1169 |
*/ |
|
1170 |
public static final URL TEXT_HTML_UTF_16LE = |
|
1171 |
new URL ("text/html; charset=utf-16le"); |
|
1172 |
||
1173 |
/** |
|
1174 |
* Doc flavor with MIME type = |
|
1175 |
* <CODE>"text/html; charset=us-ascii"</CODE>, |
|
1176 |
* print data representation class name = |
|
1177 |
* <CODE>"java.net.URL"</CODE> (byte stream). |
|
1178 |
*/ |
|
1179 |
public static final URL TEXT_HTML_US_ASCII = |
|
1180 |
new URL ("text/html; charset=us-ascii"); |
|
1181 |
||
1182 |
||
1183 |
/** |
|
1184 |
* Doc flavor with MIME type = <CODE>"application/pdf"</CODE>, print |
|
1185 |
* data representation class name = <CODE>"java.net.URL"</CODE>. |
|
1186 |
*/ |
|
1187 |
public static final URL PDF = new URL ("application/pdf"); |
|
1188 |
||
1189 |
/** |
|
1190 |
* Doc flavor with MIME type = <CODE>"application/postscript"</CODE>, |
|
1191 |
* print data representation class name = <CODE>"java.net.URL"</CODE>. |
|
1192 |
*/ |
|
1193 |
public static final URL POSTSCRIPT = new URL ("application/postscript"); |
|
1194 |
||
1195 |
/** |
|
1196 |
* Doc flavor with MIME type = <CODE>"application/vnd.hp-PCL"</CODE>, |
|
1197 |
* print data representation class name = <CODE>"java.net.URL"</CODE>. |
|
1198 |
*/ |
|
1199 |
public static final URL PCL = new URL ("application/vnd.hp-PCL"); |
|
1200 |
||
1201 |
/** |
|
1202 |
* Doc flavor with MIME type = <CODE>"image/gif"</CODE>, print data |
|
1203 |
* representation class name = <CODE>"java.net.URL"</CODE>. |
|
1204 |
*/ |
|
1205 |
public static final URL GIF = new URL ("image/gif"); |
|
1206 |
||
1207 |
/** |
|
1208 |
* Doc flavor with MIME type = <CODE>"image/jpeg"</CODE>, print data |
|
1209 |
* representation class name = <CODE>"java.net.URL"</CODE>. |
|
1210 |
*/ |
|
1211 |
public static final URL JPEG = new URL ("image/jpeg"); |
|
1212 |
||
1213 |
/** |
|
1214 |
* Doc flavor with MIME type = <CODE>"image/png"</CODE>, print data |
|
1215 |
* representation class name = <CODE>"java.net.URL"</CODE>. |
|
1216 |
*/ |
|
1217 |
public static final URL PNG = new URL ("image/png"); |
|
1218 |
||
1219 |
/** |
|
1220 |
* Doc flavor with MIME type = |
|
1221 |
* <CODE>"application/octet-stream"</CODE>, |
|
1222 |
* print data representation class name = <CODE>"java.net.URL"</CODE>. |
|
1223 |
* The client must determine that data described |
|
1224 |
* using this DocFlavor is valid for the printer. |
|
1225 |
*/ |
|
1226 |
public static final URL AUTOSENSE = new URL ("application/octet-stream"); |
|
1227 |
||
1228 |
} |
|
1229 |
||
1230 |
/** |
|
1231 |
* Class DocFlavor.CHAR_ARRAY provides predefined static constant |
|
1232 |
* DocFlavor objects for example doc flavors using a character array |
|
1233 |
* (<CODE>char[]</CODE>) as the print data representation class. As such, |
|
1234 |
* the character set is Unicode. |
|
1235 |
* <P> |
|
1236 |
* |
|
1237 |
* @author Alan Kaminsky |
|
1238 |
*/ |
|
1239 |
public static class CHAR_ARRAY extends DocFlavor { |
|
1240 |
||
1241 |
private static final long serialVersionUID = -8720590903724405128L; |
|
1242 |
||
1243 |
/** |
|
1244 |
* Constructs a new doc flavor with the given MIME type and a print |
|
1245 |
* data representation class name of |
|
1246 |
* <CODE>"[C"</CODE> (character array). |
|
1247 |
* |
|
1248 |
* @param mimeType MIME media type string. If it is a text media |
|
1249 |
* type, it is assumed to contain a |
|
1250 |
* <CODE>"charset=utf-16"</CODE> parameter. |
|
1251 |
* |
|
1252 |
* @exception NullPointerException |
|
1253 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null. |
|
1254 |
* @exception IllegalArgumentException |
|
1255 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not |
|
1256 |
* obey the syntax for a MIME media type string. |
|
1257 |
*/ |
|
1258 |
public CHAR_ARRAY (String mimeType) { |
|
1259 |
super (mimeType, "[C"); |
|
1260 |
} |
|
1261 |
||
1262 |
/** |
|
1263 |
* Doc flavor with MIME type = <CODE>"text/plain; |
|
1264 |
* charset=utf-16"</CODE>, print data representation class name = |
|
1265 |
* <CODE>"[C"</CODE> (character array). |
|
1266 |
*/ |
|
1267 |
public static final CHAR_ARRAY TEXT_PLAIN = |
|
1268 |
new CHAR_ARRAY ("text/plain; charset=utf-16"); |
|
1269 |
||
1270 |
/** |
|
1271 |
* Doc flavor with MIME type = <CODE>"text/html; |
|
1272 |
* charset=utf-16"</CODE>, print data representation class name = |
|
1273 |
* <CODE>"[C"</CODE> (character array). |
|
1274 |
*/ |
|
1275 |
public static final CHAR_ARRAY TEXT_HTML = |
|
1276 |
new CHAR_ARRAY ("text/html; charset=utf-16"); |
|
1277 |
||
1278 |
} |
|
1279 |
||
1280 |
/** |
|
1281 |
* Class DocFlavor.STRING provides predefined static constant DocFlavor |
|
1282 |
* objects for example doc flavors using a string ({@link java.lang.String |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
1283 |
* java.lang.String}) as the print data representation class. |
2 | 1284 |
* As such, the character set is Unicode. |
1285 |
* <P> |
|
1286 |
* |
|
1287 |
* @author Alan Kaminsky |
|
1288 |
*/ |
|
1289 |
public static class STRING extends DocFlavor { |
|
1290 |
||
1291 |
private static final long serialVersionUID = 4414407504887034035L; |
|
1292 |
||
1293 |
/** |
|
1294 |
* Constructs a new doc flavor with the given MIME type and a print |
|
1295 |
* data representation class name of <CODE>"java.lang.String"</CODE>. |
|
1296 |
* |
|
1297 |
* @param mimeType MIME media type string. If it is a text media |
|
1298 |
* type, it is assumed to contain a |
|
1299 |
* <CODE>"charset=utf-16"</CODE> parameter. |
|
1300 |
* |
|
1301 |
* @exception NullPointerException |
|
1302 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null. |
|
1303 |
* @exception IllegalArgumentException |
|
1304 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not |
|
1305 |
* obey the syntax for a MIME media type string. |
|
1306 |
*/ |
|
1307 |
public STRING (String mimeType) { |
|
1308 |
super (mimeType, "java.lang.String"); |
|
1309 |
} |
|
1310 |
||
1311 |
/** |
|
1312 |
* Doc flavor with MIME type = <CODE>"text/plain; |
|
1313 |
* charset=utf-16"</CODE>, print data representation class name = |
|
1314 |
* <CODE>"java.lang.String"</CODE>. |
|
1315 |
*/ |
|
1316 |
public static final STRING TEXT_PLAIN = |
|
1317 |
new STRING ("text/plain; charset=utf-16"); |
|
1318 |
||
1319 |
/** |
|
1320 |
* Doc flavor with MIME type = <CODE>"text/html; |
|
1321 |
* charset=utf-16"</CODE>, print data representation class name = |
|
1322 |
* <CODE>"java.lang.String"</CODE>. |
|
1323 |
*/ |
|
1324 |
public static final STRING TEXT_HTML = |
|
1325 |
new STRING ("text/html; charset=utf-16"); |
|
1326 |
} |
|
1327 |
||
1328 |
/** |
|
1329 |
* Class DocFlavor.READER provides predefined static constant DocFlavor |
|
1330 |
* objects for example doc flavors using a character stream ({@link |
|
20451
4cedf4e1560a
8025409: Fix javadoc comments errors and warning reported by doclint report
cl
parents:
19166
diff
changeset
|
1331 |
* java.io.Reader java.io.Reader}) as the print data |
2 | 1332 |
* representation class. As such, the character set is Unicode. |
1333 |
* <P> |
|
1334 |
* |
|
1335 |
* @author Alan Kaminsky |
|
1336 |
*/ |
|
1337 |
public static class READER extends DocFlavor { |
|
1338 |
||
1339 |
private static final long serialVersionUID = 7100295812579351567L; |
|
1340 |
||
1341 |
/** |
|
1342 |
* Constructs a new doc flavor with the given MIME type and a print |
|
1343 |
* data representation class name of\ |
|
1344 |
* <CODE>"java.io.Reader"</CODE> (character stream). |
|
1345 |
* |
|
1346 |
* @param mimeType MIME media type string. If it is a text media |
|
1347 |
* type, it is assumed to contain a |
|
1348 |
* <CODE>"charset=utf-16"</CODE> parameter. |
|
1349 |
* |
|
1350 |
* @exception NullPointerException |
|
1351 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> is null. |
|
1352 |
* @exception IllegalArgumentException |
|
1353 |
* (unchecked exception) Thrown if <CODE>mimeType</CODE> does not |
|
1354 |
* obey the syntax for a MIME media type string. |
|
1355 |
*/ |
|
1356 |
public READER (String mimeType) { |
|
1357 |
super (mimeType, "java.io.Reader"); |
|
1358 |
} |
|
1359 |
||
1360 |
/** |
|
1361 |
* Doc flavor with MIME type = <CODE>"text/plain; |
|
1362 |
* charset=utf-16"</CODE>, print data representation class name = |
|
1363 |
* <CODE>"java.io.Reader"</CODE> (character stream). |
|
1364 |
*/ |
|
1365 |
public static final READER TEXT_PLAIN = |
|
1366 |
new READER ("text/plain; charset=utf-16"); |
|
1367 |
||
1368 |
/** |
|
1369 |
* Doc flavor with MIME type = <CODE>"text/html; |
|
1370 |
* charset=utf-16"</CODE>, print data representation class name = |
|
1371 |
* <CODE>"java.io.Reader"</CODE> (character stream). |
|
1372 |
*/ |
|
1373 |
public static final READER TEXT_HTML = |
|
1374 |
new READER ("text/html; charset=utf-16"); |
|
1375 |
||
1376 |
} |
|
1377 |
||
1378 |
/** |
|
1379 |
* Class DocFlavor.SERVICE_FORMATTED provides predefined static constant |
|
1380 |
* DocFlavor objects for example doc flavors for service formatted print |
|
1381 |
* data. |
|
1382 |
* <P> |
|
1383 |
* |
|
1384 |
* @author Alan Kaminsky |
|
1385 |
*/ |
|
1386 |
public static class SERVICE_FORMATTED extends DocFlavor { |
|
1387 |
||
1388 |
private static final long serialVersionUID = 6181337766266637256L; |
|
1389 |
||
1390 |
/** |
|
1391 |
* Constructs a new doc flavor with a MIME type of |
|
1392 |
* <CODE>"application/x-java-jvm-local-objectref"</CODE> indicating |
|
1393 |
* service formatted print data and the given print data |
|
1394 |
* representation class name. |
|
1395 |
* |
|
1396 |
* @param className Fully-qualified representation class name. |
|
1397 |
* |
|
1398 |
* @exception NullPointerException |
|
1399 |
* (unchecked exception) Thrown if <CODE>className</CODE> is |
|
1400 |
* null. |
|
1401 |
*/ |
|
1402 |
public SERVICE_FORMATTED (String className) { |
|
1403 |
super ("application/x-java-jvm-local-objectref", className); |
|
1404 |
} |
|
1405 |
||
1406 |
/** |
|
1407 |
* Service formatted print data doc flavor with print data |
|
1408 |
* representation class name = |
|
1409 |
* <CODE>"java.awt.image.renderable.RenderableImage"</CODE> |
|
1410 |
* (renderable image object). |
|
1411 |
*/ |
|
1412 |
public static final SERVICE_FORMATTED RENDERABLE_IMAGE = |
|
1413 |
new SERVICE_FORMATTED("java.awt.image.renderable.RenderableImage"); |
|
1414 |
||
1415 |
/** |
|
1416 |
* Service formatted print data doc flavor with print data |
|
1417 |
* representation class name = <CODE>"java.awt.print.Printable"</CODE> |
|
1418 |
* (printable object). |
|
1419 |
*/ |
|
1420 |
public static final SERVICE_FORMATTED PRINTABLE = |
|
1421 |
new SERVICE_FORMATTED ("java.awt.print.Printable"); |
|
1422 |
||
1423 |
/** |
|
1424 |
* Service formatted print data doc flavor with print data |
|
1425 |
* representation class name = <CODE>"java.awt.print.Pageable"</CODE> |
|
1426 |
* (pageable object). |
|
1427 |
*/ |
|
1428 |
public static final SERVICE_FORMATTED PAGEABLE = |
|
1429 |
new SERVICE_FORMATTED ("java.awt.print.Pageable"); |
|
1430 |
||
1431 |
} |
|
1432 |
||
1433 |
} |