Source for javax.print.DocFlavor

   1: /* DocFlavor.java --
   2:    Copyright (C) 2004, 2006 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package javax.print;
  40: 
  41: import java.io.IOException;
  42: import java.io.ObjectInputStream;
  43: import java.io.Serializable;
  44: import java.io.StreamTokenizer;
  45: import java.io.StringReader;
  46: import java.nio.charset.Charset;
  47: import java.util.Iterator;
  48: import java.util.Map;
  49: import java.util.TreeMap;
  50: 
  51: /**
  52:  * <code>DocFlavor</code> provides a description of the format in which the 
  53:  * print data will be supplied in a print job to the print service.
  54:  * <p>
  55:  * A doc flavor consists of two parts:
  56:  * <ul>
  57:  * <li>
  58:  * The MIME type (Multipurpose Internet Mail Extensions types as described 
  59:  * in RFC 2045/2046) specifying the media format of the print data.
  60:  * </li><li>
  61:  * The representation class name which is the fully qualified name of the 
  62:  * class providing the print data to the print job. For example if the print 
  63:  * data is supplied as a byte array the representation class name will be 
  64:  * <code>"[B"</code> or for an input stream <code>"java.io.InputStream"</code>.
  65:  * </li>
  66:  * </ul>
  67:  * The <code>DocFlavor</code> class is therefore used in several places in the 
  68:  * Java Print Service API. A print service provides its supported document 
  69:  * flavors as an array of DocFlavor objects and a print job gets the flavor of
  70:  * its data to print from the <code>Doc</code> object provided as a DocFlavor
  71:  * instance.
  72:  * </p>
  73:  * <p>
  74:  * It has to be differentiated between <b>client formatted</b> and <b>service 
  75:  * formatted</b> print data. Client formatted print data is already provided 
  76:  * formatted by the client e.g. in an image format or as postscript. For 
  77:  * service formatted print data, the Java Print Service instance produces 
  78:  * the formatted print data. Here the doc flavor's representation class name 
  79:  * does specify an interface instead of the actual print data source. The 
  80:  * print service will call the methods of the given implementation of this
  81:  * interface with a special Graphics object capable of producing formatted
  82:  * print data from the graphics routines inside the interface methods.
  83:  * </p>
  84:  * <p>
  85:  * <h3>Client formatted print data document flavors</h3>
  86:  * The print service uses the representation class of the doc flavor to know 
  87:  * how to retrieve the print data. If the representation class is a 
  88:  * <code>URL</code> it will open the URL to read the print data from it. If it is 
  89:  * a <code>byte[]</code> it will directly use the array and send it to the 
  90:  * printer. There are predefined doc flavor as inner class for the most common 
  91:  * representation class types:
  92:  * <ul>
  93:  * <li>Character arrays (<code>char[]</code>): The characters of the array 
  94:  * represent the print data.</li>
  95:  * <li>Character streams (<code>java.io.Reader</code>): The whole characters 
  96:  * read from the stream represent the print data.</li>
  97:  * <li>String (<code>java.lang.String</code>): The characters of the String 
  98:  * represent the print data.</li>
  99:  * <li>Byte arrays (<code>byte[]</code>): The bytes of the array represent the 
 100:  * print data. Encoding if text content is given in the mime type.</li>
 101:  * <li>Byte streams (<code>java.io.InputStream</code>): The whole bytes read 
 102:  * from the stream represent the print data. If text content the encoding is 
 103:  * specified in the mime type.</li>
 104:  * <li>Uniform Resource Locator (<code>java.net.URL</code>): The bytes read 
 105:  * from the stream through opening of the URL represent the print data. 
 106:  * If text content the encoding is specified in the mime type.</li></li>
 107:  * </ul>
 108:  * </p>
 109:  * <p>
 110:  * <h3>Service formatted print data document flavors</h3>
 111:  * The print service uses the provided object implementing the interface
 112:  * specified by the representation class to produce the formatted print data. 
 113:  * The mime type of service formatted data is always 
 114:  * <code>"application/x-java-jvm-local-objectref"</code> to signal the local 
 115:  * reference to the print data object implementing the interface. Predefined
 116:  * doc flavor classes exist as an inner class for the three available interface 
 117:  * to produce print data:
 118:  * <ul>
 119:  * <li>Pageable object (<code>java.awt.print.Pageable</code>): A pageable object
 120:  * is supplied to the print service. The print service will call the methods of
 121:  * the interface with a Grahics object to produce the formatted print data.</li>
 122:  * <li>Printable object (<code>java.awt.print.Printable</code>): A printable object
 123:  * is supplied to the print service. The print service will call the methods of
 124:  * the interface with a Grahics object to produce the formatted print data.</li>
 125:  * <li>Renderable Image object 
 126:  * (<code>java.awt.image.renderable.RenderableImage</code>): A renderable image
 127:  * object is supplied to the print service. The print service calls methods of
 128:  * this interface to obtain the image to be printed.</li>
 129:  * </ul>
 130:  * </p>
 131:  * 
 132:  * @author Michael Koch (konqueror@gmx.de)
 133:  * @author Wolfgang Baer (WBaer@gmx.de)
 134:  */
 135: public class DocFlavor implements Cloneable, Serializable
 136: {
 137:   /**
 138:    * Predefined static <code>DocFlavor</code> objects for document
 139:    * types which use a byte array for the print data representation.
 140:    * <p>All the defined doc flavors have a print data representation 
 141:    * classname of "[B" (byte array).</p>
 142:    * 
 143:    * @author Michael Koch (konqueror@gmx.de)
 144:    */
 145:   public static class BYTE_ARRAY
 146:     extends DocFlavor
 147:   {
 148:     private static final long serialVersionUID = -9065578006593857475L;
 149: 
 150:     /**
 151:      * Byte array doc flavor with a MIME Type of "application/octet-stream".
 152:      */
 153:     public static final BYTE_ARRAY AUTOSENSE = new BYTE_ARRAY("application/octet-stream");
 154:     /**
 155:      * Byte array doc flavor with a MIME Type of "image/gif".
 156:      */
 157:     public static final BYTE_ARRAY GIF = new BYTE_ARRAY("image/gif");
 158:     /**
 159:      * Byte array doc flavor with a MIME Type of "image/jpeg".
 160:      */
 161:     public static final BYTE_ARRAY JPEG = new BYTE_ARRAY("image/jpeg");
 162:     /**
 163:      * Byte array doc flavor with a MIME Type of "application/vnd.hp-PCL".
 164:      */
 165:     public static final BYTE_ARRAY PCL = new BYTE_ARRAY("application/vnd.hp-PCL");
 166:     /**
 167:      * Byte array doc flavor with a MIME Type of "application/pdf".
 168:      */
 169:     public static final BYTE_ARRAY PDF = new BYTE_ARRAY("application/pdf");
 170:     /**
 171:      * Byte array doc flavor with a MIME Type of "image/png".
 172:      */
 173:     public static final BYTE_ARRAY PNG = new BYTE_ARRAY("image/png");
 174:     /**
 175:      * Byte array doc flavor with a MIME Type of "application/postscript".
 176:      */
 177:     public static final BYTE_ARRAY POSTSCRIPT = new BYTE_ARRAY("application/postscript");
 178:     /**
 179:      * Byte array doc flavor with a MIME Type of "text/html" in the host encoding.
 180:      */
 181:     public static final BYTE_ARRAY TEXT_HTML_HOST = new BYTE_ARRAY("text/html; charset=" + hostEncoding);
 182:     /**
 183:      * Byte array doc flavor with a MIME Type of "text/html; charset=us-ascii".
 184:      */
 185:     public static final BYTE_ARRAY TEXT_HTML_US_ASCII = new BYTE_ARRAY("text/html; charset=us-ascii");
 186:     /**
 187:      * Byte array doc flavor with a MIME Type of "text/html; charset=utf-16".
 188:      */
 189:     public static final BYTE_ARRAY TEXT_HTML_UTF_16 = new BYTE_ARRAY("text/html; charset=utf-16");
 190:     /**
 191:      * Byte array doc flavor with a MIME Type of "text/html; charset=utf-16be".
 192:      */
 193:     public static final BYTE_ARRAY TEXT_HTML_UTF_16BE = new BYTE_ARRAY("text/html; charset=utf-16be");
 194:     /**
 195:      * Byte array doc flavor with a MIME Type of "text/html; charset=utf-16le".
 196:      */
 197:     public static final BYTE_ARRAY TEXT_HTML_UTF_16LE = new BYTE_ARRAY("text/html; charset=utf-16le");
 198:     /**
 199:      * Byte array doc flavor with a MIME Type of "text/html; charset=utf-8".
 200:      */
 201:     public static final BYTE_ARRAY TEXT_HTML_UTF_8 = new BYTE_ARRAY("text/html; charset=utf-8");
 202:     /**
 203:      * Byte array doc flavor with a MIME Type of "text/plain" in the host encoding.
 204:      */
 205:     public static final BYTE_ARRAY TEXT_PLAIN_HOST = new BYTE_ARRAY("text/plain; charset=" + hostEncoding);
 206:     /**
 207:      * Byte array doc flavor with a MIME Type of "text/plain; charset=us-ascii".
 208:      */
 209:     public static final BYTE_ARRAY TEXT_PLAIN_US_ASCII = new BYTE_ARRAY("text/plain; charset=us-ascii");    
 210:     /**
 211:      * Byte array doc flavor with a MIME Type of "text/plain; charset=utf-16".
 212:      */
 213:     public static final BYTE_ARRAY TEXT_PLAIN_UTF_16 = new BYTE_ARRAY("text/plain; charset=utf-16");
 214:     /**
 215:      * Byte array doc flavor with a MIME Type of "text/plain; charset=utf-16be".
 216:      */
 217:     public static final BYTE_ARRAY TEXT_PLAIN_UTF_16BE = new BYTE_ARRAY("text/plain; charset=utf-16be");
 218:     /**
 219:      * Byte array doc flavor with a MIME Type of "text/plain; charset=utf-16le".
 220:      */
 221:     public static final BYTE_ARRAY TEXT_PLAIN_UTF_16LE = new BYTE_ARRAY("text/plain; charset=utf-16le");
 222:     /**
 223:      * Byte array doc flavor with a MIME Type of "text/plain; charset=utf-8".
 224:      */
 225:     public static final BYTE_ARRAY TEXT_PLAIN_UTF_8 = new BYTE_ARRAY("text/plain; charset=utf-8");
 226:     
 227:     /**
 228:      * Constructor for doc flavor objects with the given MIME type 
 229:      * and a print data representation class name of "[B".
 230:      * 
 231:      * @param mimeType the mime type string
 232:      * 
 233:      * @throws NullPointerException if mimeType is <code>null</code>.
 234:      * @throws IllegalArgumentException if mimeType has the wrong syntax.
 235:      */
 236:     public BYTE_ARRAY(String mimeType)
 237:     {
 238:       super(mimeType, "[B");
 239:     }
 240:   }
 241:   
 242:   /**
 243:    * Predefined static <code>DocFlavor</code> objects for document
 244:    * types which use a char array for the print data representation.
 245:    * <p>All the defined doc flavors have a print data representation 
 246:    * classname of "[C" (char array).</p>
 247:    * 
 248:    * @author Michael Koch (konqueror@gmx.de)
 249:    */
 250:   public static class CHAR_ARRAY
 251:     extends DocFlavor
 252:   {
 253:     private static final long serialVersionUID = -8720590903724405128L;
 254:     
 255:     /**
 256:      * Char array doc flavor with a MIME Type of "text/html; charset=utf-16".
 257:      */
 258:     public static final DocFlavor.CHAR_ARRAY TEXT_HTML = new CHAR_ARRAY("text/html; charset=utf-16");
 259:     /**
 260:      * Char array doc flavor with a MIME Type of "text/plain; charset=utf-16".
 261:      */
 262:     public static final DocFlavor.CHAR_ARRAY TEXT_PLAIN = new CHAR_ARRAY("text/plain; charset=utf-16");
 263: 
 264:     /**
 265:      * Constructor for doc flavor objects with the given MIME type 
 266:      * and a print data representation class name of "[C".
 267:      * 
 268:      * @param mimeType the mime type string
 269:      * 
 270:      * @throws NullPointerException if mimeType is <code>null</code>.
 271:      * @throws IllegalArgumentException if mimeType has the wrong syntax.
 272:      */
 273:     public CHAR_ARRAY(String mimeType)
 274:     {
 275:       super(mimeType, "[C");
 276:     }
 277:   }
 278:   
 279:   /**
 280:    * Predefined static <code>DocFlavor</code> objects for document
 281:    * types which use an InputStream to retrieve the print data.
 282:    * <p>All the defined doc flavors have a print data representation 
 283:    * classname of "java.io.InputStream".</p>
 284:    * 
 285:    * @author Michael Koch (konqueror@gmx.de)
 286:    */
 287:   public static class INPUT_STREAM
 288:     extends DocFlavor
 289:   {
 290:     private static final long serialVersionUID = -7045842700749194127L;
 291: 
 292:     /**
 293:      * InputStream doc flavor with a MIME Type of "application/octet-stream".
 294:      */
 295:     public static final INPUT_STREAM AUTOSENSE = new INPUT_STREAM("application/octet-stream");
 296:     /**
 297:      * InputStream doc flavor with a MIME Type of "image/gif".
 298:      */
 299:     public static final INPUT_STREAM GIF = new INPUT_STREAM("image/gif");
 300:     /**
 301:      * InputStream doc flavor with a MIME Type of "image/jpeg".
 302:      */
 303:     public static final INPUT_STREAM JPEG = new INPUT_STREAM("image/jpeg");
 304:     /**
 305:      * InputStream doc flavor with a MIME Type of "application/vnd.hp-PCL".
 306:      */
 307:     public static final INPUT_STREAM PCL = new INPUT_STREAM("application/vnd.hp-PCL");
 308:     /**
 309:      * InputStream doc flavor with a MIME Type of "application/pdf".
 310:      */
 311:     public static final INPUT_STREAM PDF = new INPUT_STREAM("application/pdf");
 312:     /**
 313:      * InputStream doc flavor with a MIME Type of "image/png".
 314:      */
 315:     public static final INPUT_STREAM PNG = new INPUT_STREAM("image/png");
 316:     /**
 317:      * InputStream doc flavor with a MIME Type of "application/postscript".
 318:      */
 319:     public static final INPUT_STREAM POSTSCRIPT = new INPUT_STREAM("application/postscript");
 320:     /**
 321:      * InputStream doc flavor with a MIME Type of "text/html" in the host encoding.
 322:      */
 323:     public static final INPUT_STREAM TEXT_HTML_HOST = new INPUT_STREAM("text/html; charset=" + hostEncoding);
 324:     /**
 325:      * InputStream doc flavor with a MIME Type of "text/html; charset=us-ascii".
 326:      */
 327:     public static final INPUT_STREAM TEXT_HTML_US_ASCII = new INPUT_STREAM("text/html; charset=us-ascii");
 328:     /**
 329:      * InputStream doc flavor with a MIME Type of "text/html; charset=utf-16".
 330:      */
 331:     public static final INPUT_STREAM TEXT_HTML_UTF_16 = new INPUT_STREAM("text/html; charset=utf-16");
 332:     /**
 333:      * InputStream doc flavor with a MIME Type of "text/html; charset=utf-16be".
 334:      */
 335:     public static final INPUT_STREAM TEXT_HTML_UTF_16BE = new INPUT_STREAM("text/html; charset=utf-16be");
 336:     /**
 337:      * InputStream doc flavor with a MIME Type of "text/html; charset=utf-16le".
 338:      */
 339:     public static final INPUT_STREAM TEXT_HTML_UTF_16LE = new INPUT_STREAM("text/html; charset=utf-16le");
 340:     /**
 341:      * InputStream doc flavor with a MIME Type of "text/html; charset=utf-8".
 342:      */
 343:     public static final INPUT_STREAM TEXT_HTML_UTF_8 = new INPUT_STREAM("text/html; charset=utf-8");
 344:     /**
 345:      * InputStream doc flavor with a MIME Type of "text/plain" in the host encoding.
 346:      */
 347:     public static final INPUT_STREAM TEXT_PLAIN_HOST = new INPUT_STREAM("text/plain; charset=" + hostEncoding);
 348:     /**
 349:      * InputStream doc flavor with a MIME Type of "text/plain; charset=us-ascii".
 350:      */
 351:     public static final INPUT_STREAM TEXT_PLAIN_US_ASCII = new INPUT_STREAM("text/plain; charset=us-ascii");
 352:     /**
 353:      * InputStream doc flavor with a MIME Type of "text/plain; charset=utf-16".
 354:      */
 355:     public static final INPUT_STREAM TEXT_PLAIN_UTF_16 = new INPUT_STREAM("text/plain; charset=utf-16");
 356:     /**
 357:      * InputStream doc flavor with a MIME Type of "text/plain; charset=utf-16be".
 358:      */
 359:     public static final INPUT_STREAM TEXT_PLAIN_UTF_16BE = new INPUT_STREAM("text/plain; charset=utf-16be");
 360:     /**
 361:      * InputStream doc flavor with a MIME Type of "text/plain; charset=utf-16le".
 362:      */
 363:     public static final INPUT_STREAM TEXT_PLAIN_UTF_16LE = new INPUT_STREAM("text/plain; charset=utf-16le");
 364:     /**
 365:      * InputStream doc flavor with a MIME Type of "text/plain; charset=utf-8".
 366:      */
 367:     public static final INPUT_STREAM TEXT_PLAIN_UTF_8 = new INPUT_STREAM("text/plain; charset=utf-8");
 368:     
 369:     /**
 370:      * Constructor for doc flavor objects with the given MIME type 
 371:      * and a print data representation class name of "java.io.InputStream".
 372:      * 
 373:      * @param mimeType the mime type string
 374:      * 
 375:      * @throws NullPointerException if mimeType is <code>null</code>.
 376:      * @throws IllegalArgumentException if mimeType has the wrong syntax.
 377:      */
 378:     public INPUT_STREAM(String mimeType)
 379:     {
 380:       super(mimeType, "java.io.InputStream");
 381:     }
 382:   }
 383:   
 384:   /**
 385:    * Predefined static <code>DocFlavor</code> objects for document
 386:    * types which use an Reader to retrieve the print data.
 387:    * <p>All the defined doc flavors have a print data representation 
 388:    * classname of "java.io.Reader".</p>
 389:    * 
 390:    * @author Michael Koch (konqueror@gmx.de)
 391:    */
 392:   public static class READER
 393:     extends DocFlavor
 394:   {
 395:     private static final long serialVersionUID = 7100295812579351567L;
 396: 
 397:     /**
 398:      * Reader doc flavor with a MIME Type of "text/html; charset=utf-16".
 399:      */
 400:     public static final DocFlavor.READER TEXT_HTML = new READER("text/html; charset=utf-16");
 401:     /**
 402:      * Reader doc flavor with a MIME Type of "text/plain; charset=utf-16".
 403:      */
 404:     public static final DocFlavor.READER TEXT_PLAIN = new READER("text/plain; charset=utf-16");
 405:     
 406:     /**
 407:      * Constructor for doc flavor objects with the given MIME type 
 408:      * and a print data representation class name of "java.io.Reader".
 409:      * 
 410:      * @param mimeType the mime type string
 411:      * 
 412:      * @throws NullPointerException if mimeType is <code>null</code>.
 413:      * @throws IllegalArgumentException if mimeType has the wrong syntax.
 414:      */
 415:     public READER(String mimeType)
 416:     {
 417:       super(mimeType, "java.io.Reader");
 418:     }
 419:   }
 420:   
 421:   /**
 422:    * Predefined static <code>DocFlavor</code> objects for document
 423:    * types which use service formatted print data.
 424:    * <p>All the defined doc flavors have a MIME type of 
 425:    * "application/x-java-jvm-local-objectref".</p>
 426:    * 
 427:    * @author Michael Koch (konqueror@gmx.de)
 428:    */
 429:   public static class SERVICE_FORMATTED
 430:     extends DocFlavor
 431:   {
 432:     private static final long serialVersionUID = 6181337766266637256L;
 433: 
 434:     /**
 435:      * Service formatted doc flavor with a representation class of 
 436:      * "java.awt.print.Pageable".
 437:      */
 438:     public static final DocFlavor.SERVICE_FORMATTED PAGEABLE = new SERVICE_FORMATTED("java.awt.print.Pageable");
 439:     /**
 440:      * Service formatted doc flavor with a representation class of 
 441:      * "java.awt.print.Printable".
 442:      */
 443:     public static final DocFlavor.SERVICE_FORMATTED PRINTABLE = new SERVICE_FORMATTED("java.awt.print.Printable");
 444:     /**
 445:      * Service formatted doc flavor with a representation class of 
 446:      * "java.awt.image.renderable.RenderableImage".
 447:      */
 448:     public static final DocFlavor.SERVICE_FORMATTED RENDERABLE_IMAGE = new SERVICE_FORMATTED("java.awt.image.renderable.RenderableImage");
 449:     
 450:     /**
 451:      * Constructor for doc flavor objects with a MIME type of 
 452:      * "application/x-java-jvm-local-objectref" and the given
 453:      * print data representation classname.
 454:      * 
 455:      * @param className the representation classname
 456:      * 
 457:      * @throws NullPointerException if className is <code>null</code>.
 458:      */
 459:     public SERVICE_FORMATTED(String className)
 460:     {
 461:       super("application/x-java-jvm-local-objectref", className);
 462:     }
 463:   }
 464:   
 465:   /**
 466:    * Predefined static <code>DocFlavor</code> objects for document
 467:    * types which use a String for the print data representation.
 468:    * <p>All the defined doc flavors have a print data representation 
 469:    * classname of "java.lang.String".</p>
 470:    * 
 471:    * @author Michael Koch (konqueror@gmx.de)
 472:    */
 473:   public static class STRING
 474:     extends DocFlavor
 475:   {
 476:     private static final long serialVersionUID = 4414407504887034035L;
 477: 
 478:     /**
 479:      * String doc flavor with a MIME Type of "text/html; charset=utf-16".
 480:      */
 481:     public static final DocFlavor.STRING TEXT_HTML = new STRING("text/html; charset=utf-16");
 482:     /**
 483:      * String doc flavor with a MIME Type of "text/plain; charset=utf-16".
 484:      */
 485:     public static final DocFlavor.STRING TEXT_PLAIN = new STRING("text/plain; charset=utf-16");
 486:     
 487:     /**
 488:      * Constructor for doc flavor objects with the given MIME type 
 489:      * and a print data representation class name of "java.lang.String".
 490:      * 
 491:      * @param mimeType the mime type string
 492:      * 
 493:      * @throws NullPointerException if mimeType is <code>null</code>.
 494:      * @throws IllegalArgumentException if mimeType has the wrong syntax.
 495:      */
 496:     public STRING(String mimeType)
 497:     {
 498:       super(mimeType, "java.lang.String");
 499:     }
 500:   }
 501:   
 502:   /**
 503:    * Predefined static <code>DocFlavor</code> objects for document
 504:    * types which have an URL where to retrieve the print data.
 505:    * <p>All the defined doc flavors have a print data representation 
 506:    * classname of "java.net.URL".</p>
 507:    * 
 508:    * @author Michael Koch (konqueror@gmx.de)
 509:    */
 510:   public static class URL
 511:     extends DocFlavor
 512:   {
 513:     private static final long serialVersionUID = 2936725788144902062L;
 514: 
 515:     /**
 516:      * URL doc flavor with a MIME Type of "application/octet-stream".
 517:      */
 518:     public static final DocFlavor.URL AUTOSENSE = new URL("application/octet-stream");
 519:     /**
 520:      * URL doc flavor with a MIME Type of "image/gif".
 521:      */
 522:     public static final DocFlavor.URL GIF = new URL("image/gif");
 523:     /**
 524:      * URL doc flavor with a MIME Type of "image/jpeg".
 525:      */
 526:     public static final DocFlavor.URL JPEG = new URL("image/jpeg");
 527:     /**
 528:      * URL doc flavor with a MIME Type of "application/vnd.hp-PCL".
 529:      */
 530:     public static final DocFlavor.URL PCL = new URL("application/vnd.hp-PCL");
 531:     /**
 532:      * URL doc flavor with a MIME Type of "application/pdf".
 533:      */
 534:     public static final DocFlavor.URL PDF = new URL("application/pdf");
 535:     /**
 536:      * URL doc flavor with a MIME Type of "image/png".
 537:      */
 538:     public static final DocFlavor.URL PNG = new URL("image/png");
 539:     /**
 540:      * URL doc flavor with a MIME Type of "application/postscript".
 541:      */
 542:     public static final DocFlavor.URL POSTSCRIPT = new URL("application/postscript");
 543:     /**
 544:      * URL doc flavor with a MIME Type of "text/html" in the host encoding.
 545:      */
 546:     public static final DocFlavor.URL TEXT_HTML_HOST = new URL("text/html; charset=" + hostEncoding);
 547:     /**
 548:      * URL doc flavor with a MIME Type of "text/html; charset=us-ascii".
 549:      */
 550:     public static final DocFlavor.URL TEXT_HTML_US_ASCII = new URL("text/html; charset=us-ascii");
 551:     /**
 552:      * URL doc flavor with a MIME Type of "text/html; charset=utf-16".
 553:      */
 554:     public static final DocFlavor.URL TEXT_HTML_UTF_16 = new URL("text/html; charset=utf-16");
 555:     /**
 556:      * URL doc flavor with a MIME Type of "text/html; charset=utf-16be".
 557:      */
 558:     public static final DocFlavor.URL TEXT_HTML_UTF_16BE = new URL("text/html; charset=utf-16be");
 559:     /**
 560:      * URL doc flavor with a MIME Type of "text/html; charset=utf-16le".
 561:      */
 562:     public static final DocFlavor.URL TEXT_HTML_UTF_16LE = new URL("text/html; charset=utf-16le");
 563:     /**
 564:      * URL doc flavor with a MIME Type of "text/html; charset=utf-8".
 565:      */
 566:     public static final DocFlavor.URL TEXT_HTML_UTF_8 = new URL("text/html; charset=utf-8");
 567:     /**
 568:      * URL doc flavor with a MIME Type of "text/plain" in the host encoding.
 569:      */
 570:     public static final DocFlavor.URL TEXT_PLAIN_HOST = new URL("text/plain; charset=" + hostEncoding);
 571:     /**
 572:      * URL doc flavor with a MIME Type of "text/plain; charset=us-ascii".
 573:      */
 574:     public static final DocFlavor.URL TEXT_PLAIN_US_ASCII = new URL("text/plain; charset=us-ascii");
 575:     /**
 576:      * URL doc flavor with a MIME Type of "text/plain; charset=utf-16".
 577:      */
 578:     public static final DocFlavor.URL TEXT_PLAIN_UTF_16 = new URL("text/plain; charset=utf-16");
 579:     /**
 580:      * URL doc flavor with a MIME Type of "text/plain; charset=utf-16be".
 581:      */
 582:     public static final DocFlavor.URL TEXT_PLAIN_UTF_16BE = new URL("text/plain; charset=utf-16be");
 583:     /**
 584:      * URL doc flavor with a MIME Type of "text/plain; charset=utf-16le".
 585:      */
 586:     public static final DocFlavor.URL TEXT_PLAIN_UTF_16LE = new URL("text/plain; charset=utf-16le");
 587:     /**
 588:      * URL doc flavor with a MIME Type of "text/plain; charset=utf-8".
 589:      */
 590:     public static final DocFlavor.URL TEXT_PLAIN_UTF_8 = new URL("text/plain; charset=utf-8");
 591:     
 592:     /**
 593:      * Constructor for doc flavor objects with the given MIME type 
 594:      * and a print data representation class name of "java.net.URL".
 595:      * 
 596:      * @param mimeType the mime type string
 597:      * 
 598:      * @throws NullPointerException if mimeType is <code>null</code>.
 599:      * @throws IllegalArgumentException if mimeType has the wrong syntax.
 600:      */
 601:     public URL(String mimeType)
 602:     {
 603:       super(mimeType, "java.net.URL");
 604:     }
 605:   }
 606:   
 607:   private static final long serialVersionUID = -4512080796965449721L;
 608:   
 609:   /**
 610:    * The string representing the host encoding. This is the encoding
 611:    * used in the predefined HOST doc flavors 
 612:    * (e.g. {@link BYTE_ARRAY#TEXT_HTML_HOST}).
 613:    */
 614:   public static final String hostEncoding = Charset.defaultCharset().name();
 615: 
 616:   private transient String mediaSubtype;
 617:   private transient String mediaType;
 618:   private transient TreeMap params;
 619:   
 620:   // name as defined in Serialized Form JDK 1.4
 621:   private String myClassName;
 622:   
 623:   /**
 624:    * Constructs a <code>DocFlavor</code> object with the given MIME type and 
 625:    * representation class name.
 626:    * 
 627:    * @param mimeType the MIME type string.
 628:    * @param className the fully-qualified name of the representation class.
 629:    * 
 630:    * @throws NullPointerException if mimeType or className are <code>null</code>.
 631:    * @throws IllegalArgumentException if given mimeType has syntax errors.
 632:    */
 633:   public DocFlavor(String mimeType, String className)
 634:   {
 635:     if (mimeType == null || className == null)
 636:       throw new NullPointerException();
 637: 
 638:     params = new TreeMap();
 639:     parseMimeType(mimeType);
 640:     
 641:     myClassName = className;
 642:   }
 643:   
 644:   /**
 645:    * Parses the given string as MIME type.
 646:    * The mediatype, mediasubtype and all parameter/value
 647:    * combinations are extracted, comments are dropped.
 648:    *  
 649:    * @param mimeType the string to parse
 650:    * @throws IllegalArgumentException if not conformant.
 651:    */
 652:   private void parseMimeType(String mimeType)
 653:   {
 654:     int MEDIA = 1;
 655:     int MEDIASUB = 2;
 656:     int PARAM_NAME = 3;
 657:     int PARAM_VALUE = 4;
 658:     int COMMENT_START = 5;
 659:     
 660:     int state = 0;
 661:     int lastState = 0; // keeps track of state before comment
 662:     int tok;
 663:     
 664:     try
 665:       {
 666:         String paramName = null;
 667:         StreamTokenizer in = new StreamTokenizer(new StringReader(mimeType));
 668:         in.resetSyntax();
 669:         // Allowed characters are anything except:
 670:         // SPACE, CTLs (= Unicode characters U+0000 - U+001F and U+007F)
 671:         // and tspecials ( ) < > @ , ; : \ " / [ ] ? =
 672:         in.whitespaceChars(0x00, 0x20);
 673:         in.whitespaceChars(0x7F, 0x7F);
 674:         in.wordChars('A', 'Z');
 675:         in.wordChars('a', 'z');
 676:         in.wordChars('0', '9');
 677:         in.wordChars(0xA0, 0xFF);
 678:         in.wordChars(0x21, 0x21);
 679:         in.wordChars(0x23, 0x27);
 680:         in.wordChars(0x2A, 0x2B);
 681:         in.wordChars(0x2D, 0x2E);
 682:         in.wordChars(0x5E, 0x60);
 683:         in.wordChars(0x7B, 0x7E);
 684:         in.quoteChar('"');
 685: 
 686:         while ((tok = in.nextToken()) != StreamTokenizer.TT_EOF)
 687:           {
 688:             switch (tok)
 689:               {
 690:               case StreamTokenizer.TT_WORD:
 691:                 if (state == 0)
 692:                   {
 693:                     mediaType = in.sval.toLowerCase();
 694:                     state = MEDIA;
 695:                     break;
 696:                   }
 697:                 if (state == MEDIA)
 698:                   {
 699:                     mediaSubtype = in.sval.toLowerCase();
 700:                     state = MEDIASUB;
 701:                     break;
 702:                   }
 703:                 // begin of parameters is either after mediasub or a parameter value
 704:                 if (state == MEDIASUB || state == PARAM_VALUE)
 705:                   {
 706:                     paramName = in.sval.toLowerCase();
 707:                     state = PARAM_NAME;
 708:                     break;
 709:                   }
 710:                 // a parameter always needs to follow a value
 711:                 if (state == PARAM_NAME)
 712:                   {
 713:                     String paramValue = in.sval;
 714:                     // if a charset param the value needs to be stored lowercase
 715:                     if (paramName.equals("charset"))
 716:                       paramValue = paramValue.toLowerCase();
 717: 
 718:                     state = PARAM_VALUE;
 719:                     params.put(paramName, paramValue);
 720:                     break;
 721:                   }
 722:                 if (state == COMMENT_START)
 723:                   {
 724:                     // ignore;
 725:                     break;
 726:                   }
 727:                 break;
 728:               case '/':
 729:                 // may only occur after the mediatype
 730:                 if (state != MEDIA)
 731:                   throw new IllegalArgumentException();
 732: 
 733:                 break;
 734:               case '=':
 735:                 // may only occur after a parameter
 736:                 if (state != PARAM_NAME)
 737:                   throw new IllegalArgumentException();
 738: 
 739:                 break;
 740:               case ';':
 741:                 // differentiates mime type and parameters/value combinations
 742:                 if (state != MEDIASUB && state != PARAM_VALUE)
 743:                   throw new IllegalArgumentException();
 744: 
 745:                 break;
 746:               case '(': // begin comment
 747:                 lastState = state;
 748:                 state = COMMENT_START;
 749:                 break;
 750:               case ')': // end comment
 751:                 state = lastState;
 752:                 break;
 753:               // a parameter always needs to follow a value / or quoted value
 754:               case '"':
 755:                 if (state == PARAM_NAME)
 756:                   {
 757:                     String paramValue = in.sval;
 758:                     // if a charset param the value needs to be stored lowercase
 759:                     if (paramName.equals("charset"))
 760:                       paramValue = paramValue.toLowerCase();
 761: 
 762:                     state = PARAM_VALUE;
 763:                     params.put(paramName, paramValue);
 764:                     break;
 765:                   }
 766: 
 767:                 // only values may be quoted
 768:                 throw new IllegalArgumentException();
 769:               default:
 770:                 // if any other char is observed its not allowed
 771:                 throw new IllegalArgumentException();
 772:               }
 773:           }
 774:       }
 775:     catch (IOException e)
 776:       {
 777:         // should not happen as mimetype str cannot be null
 778:         throw new InternalError("IOException during parsing String " + mimeType);
 779:       }
 780:   }
 781:   
 782:   /**
 783:    * Checks if this doc flavor object is equal to the given object.
 784:    * <p>
 785:    * Two doc flavor objects are considered equal if the provided object is not
 786:    * <code>null</code> and an instance of <code>DocFlavor</code>. The MIME
 787:    * types has to be equal in their media type, media subtype, their
 788:    * paramter/value combinations and the representation classname.
 789:    * </p>
 790:    * 
 791:    * @param obj the object to test.
 792:    * @return <code>true</code> if equal, <code>false</code> otherwise.
 793:    */
 794:   public boolean equals(Object obj)
 795:   {
 796:     if (! (obj instanceof DocFlavor))
 797:       return false;
 798: 
 799:     DocFlavor tmp = (DocFlavor) obj;
 800: 
 801:     return (getMimeType().equals(tmp.getMimeType())
 802:         && getRepresentationClassName().equals(tmp.getRepresentationClassName()));
 803:   }
 804: 
 805:   /**
 806:    * Returns the media subtype of this flavor object.
 807:    * A mimetype of "text/html; charset=us-ascii" will
 808:    * return "html" as the media subtype. 
 809:    * 
 810:    * @return The media subtype.
 811:    */
 812:   public String getMediaSubtype()
 813:   {
 814:     return mediaSubtype;
 815:   }
 816: 
 817:   /**
 818:    * Returns the media type of this flavor object.
 819:    * A mimetype of "text/html; charset=us-ascii" will
 820:    * return "text" as the media type.
 821:    * 
 822:    * @return The media type.
 823:    */
 824:   public String getMediaType()
 825:   {
 826:     return mediaType;
 827:   }
 828: 
 829:   /**
 830:    * Returns the mime type of this flavor object.
 831:    * The mimetype will have every parameter value
 832:    * enclosed in quotes.
 833:    * 
 834:    * @return The mime type.
 835:    */
 836:   public String getMimeType()
 837:   {
 838:     String mimeType = getMediaType() + "/" + getMediaSubtype();
 839:     Iterator it = params.entrySet().iterator();
 840: 
 841:     while (it.hasNext())
 842:       {
 843:     Map.Entry entry = (Map.Entry) it.next();
 844:     mimeType += "; " + entry.getKey() + "=\"" + entry.getValue() + "\"";
 845:       }
 846: 
 847:     return mimeType;
 848:   }
 849: 
 850:   /**
 851:    * Returns the value for an optional parameter of the mime type of this
 852:    * flavor object.
 853:    * 
 854:    * @param paramName the name of the parameter
 855:    * @return The value for the parameter, or <code>null</code> if none bound.
 856:    * @throws NullPointerException if paramName is <code>null</code>.
 857:    */
 858:   public String getParameter(String paramName)
 859:   {
 860:     if (paramName == null)
 861:       throw new NullPointerException();
 862:     
 863:     return (String) params.get(paramName.toLowerCase());
 864:   }
 865: 
 866:   /**
 867:    * Returns the name of the representation class of this flavor object.
 868:    * 
 869:    * @return The representation classname.
 870:    */
 871:   public String getRepresentationClassName()
 872:   {
 873:     return myClassName;
 874:   }
 875: 
 876:   /**
 877:    * Returns a hash code for this doc flavor object.
 878:    * 
 879:    * @return The hashcode.
 880:    */
 881:   public int hashCode()
 882:   {
 883:     return ((mediaType.hashCode()
 884:          * mediaSubtype.hashCode()
 885:          * myClassName.hashCode()) ^ params.hashCode());
 886:   }
 887: 
 888:   /**
 889:    * Returns a string representation of this doc flavor object.
 890:    * The returned string is of the form
 891:    * getMimeType() + "; class=\"" + getRepresentationClassName() + "\"";
 892:    * 
 893:    * @return The constructed string representation.
 894:    */
 895:   public String toString()
 896:   {
 897:     return getMimeType() + "; class=\"" + getRepresentationClassName() + "\"";
 898:   }
 899:   
 900:   // needs special treatment for serialization
 901:   private void readObject(ObjectInputStream stream) 
 902:     throws IOException, ClassNotFoundException
 903:   {
 904:     params = new TreeMap();
 905:     myClassName = (String) stream.readObject();
 906:     parseMimeType((String) stream.readObject());
 907:   }
 908: 
 909:   private void writeObject(java.io.ObjectOutputStream stream)
 910:     throws IOException
 911:   {
 912:     stream.writeObject(myClassName);
 913:     stream.writeObject(getMimeType());
 914:   }
 915: }