1 /*
   2  * Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
   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
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  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  *
  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.
  24  */
  25 
  26 package sun.print;
  27 
  28 import java.io.FilePermission;
  29 
  30 import java.awt.Color;
  31 import java.awt.Dialog;
  32 import java.awt.Frame;

  33 import java.awt.Graphics2D;
  34 import java.awt.GraphicsConfiguration;
  35 import java.awt.GraphicsEnvironment;
  36 import java.awt.HeadlessException;
  37 import java.awt.KeyboardFocusManager;
  38 import java.awt.Rectangle;
  39 import java.awt.Shape;
  40 import java.awt.geom.AffineTransform;

  41 import java.awt.geom.Point2D;
  42 import java.awt.geom.Rectangle2D;
  43 import java.awt.image.BufferedImage;
  44 import java.awt.print.Book;
  45 import java.awt.print.Pageable;
  46 import java.awt.print.PageFormat;
  47 import java.awt.print.Paper;
  48 import java.awt.print.Printable;
  49 import java.awt.print.PrinterAbortException;
  50 import java.awt.print.PrinterException;
  51 import java.awt.print.PrinterJob;
  52 import java.awt.Window;
  53 import java.io.File;
  54 import java.io.IOException;
  55 import java.util.ArrayList;

  56 import java.util.Locale;
  57 import sun.awt.image.ByteInterleavedRaster;
  58 
  59 import javax.print.Doc;
  60 import javax.print.DocFlavor;
  61 import javax.print.DocPrintJob;
  62 import javax.print.PrintException;
  63 import javax.print.PrintService;
  64 import javax.print.PrintServiceLookup;
  65 import javax.print.ServiceUI;
  66 import javax.print.StreamPrintService;
  67 import javax.print.StreamPrintServiceFactory;
  68 import javax.print.attribute.Attribute;
  69 import javax.print.attribute.AttributeSet;
  70 import javax.print.attribute.HashPrintRequestAttributeSet;
  71 import javax.print.attribute.PrintRequestAttributeSet;
  72 import javax.print.attribute.ResolutionSyntax;
  73 import javax.print.attribute.Size2DSyntax;

  74 import javax.print.attribute.standard.Copies;
  75 import javax.print.attribute.standard.Destination;
  76 import javax.print.attribute.standard.DialogTypeSelection;
  77 import javax.print.attribute.standard.Fidelity;
  78 import javax.print.attribute.standard.JobName;
  79 import javax.print.attribute.standard.JobSheets;
  80 import javax.print.attribute.standard.Media;
  81 import javax.print.attribute.standard.MediaPrintableArea;
  82 import javax.print.attribute.standard.MediaSize;
  83 import javax.print.attribute.standard.MediaSizeName;
  84 import javax.print.attribute.standard.OrientationRequested;
  85 import javax.print.attribute.standard.PageRanges;
  86 import javax.print.attribute.standard.PrinterResolution;
  87 import javax.print.attribute.standard.PrinterState;
  88 import javax.print.attribute.standard.PrinterStateReason;
  89 import javax.print.attribute.standard.PrinterStateReasons;
  90 import javax.print.attribute.standard.PrinterIsAcceptingJobs;
  91 import javax.print.attribute.standard.RequestingUserName;
  92 import javax.print.attribute.standard.SheetCollate;
  93 import javax.print.attribute.standard.Sides;
  94 
  95 import sun.print.PageableDoc;
  96 import sun.print.ServiceDialog;
  97 import sun.print.SunPrinterJobService;
  98 import sun.print.SunPageSelection;
  99 
 100 /**
 101  * A class which rasterizes a printer job.
 102  *
 103  * @author Richard Blanchard
 104  */
 105 public abstract class RasterPrinterJob extends PrinterJob {
 106 
 107  /* Class Constants */
 108 
 109      /* Printer destination type. */
 110     protected static final int PRINTER = 0;
 111 
 112      /* File destination type.  */
 113     protected static final int FILE = 1;
 114 
 115     /* Stream destination type.  */
 116     protected static final int STREAM = 2;
 117 
 118     /**
 119      * Pageable MAX pages
 120      */
 121     protected static final int MAX_UNKNOWN_PAGES = 9999;
 122 
 123     protected static final int PD_ALLPAGES = 0x00000000;
 124     protected static final int PD_SELECTION = 0x00000001;
 125     protected static final int PD_PAGENUMS = 0x00000002;
 126     protected static final int PD_NOSELECTION = 0x00000004;
 127 
 128     /**
 129      * Maximum amount of memory in bytes to use for the
 130      * buffered image "band". 4Mb is a compromise between
 131      * limiting the number of bands on hi-res printers and
 132      * not using too much of the Java heap or causing paging
 133      * on systems with little RAM.
 134      */
 135     private static final int MAX_BAND_SIZE = (1024 * 1024 * 4);
 136 
 137     /* Dots Per Inch */
 138     private static final float DPI = 72.0f;
 139 
 140     /**
 141      * Useful mainly for debugging, this system property
 142      * can be used to force the printing code to print
 143      * using a particular pipeline. The two currently
 144      * supported values are FORCE_RASTER and FORCE_PDL.
 145      */
 146     private static final String FORCE_PIPE_PROP = "sun.java2d.print.pipeline";
 147 
 148     /**
 149      * When the system property FORCE_PIPE_PROP has this value
 150      * then each page of a print job will be rendered through
 151      * the raster pipeline.
 152      */
 153     private static final String FORCE_RASTER = "raster";
 154 
 155     /**
 156      * When the system property FORCE_PIPE_PROP has this value
 157      * then each page of a print job will be rendered through
 158      * the PDL pipeline.
 159      */
 160     private static final String FORCE_PDL = "pdl";
 161 
 162     /**
 163      * When the system property SHAPE_TEXT_PROP has this value
 164      * then text is always rendered as a shape, and no attempt is made
 165      * to match the font through GDI
 166      */
 167     private static final String SHAPE_TEXT_PROP = "sun.java2d.print.shapetext";
 168 
 169     /**
 170      * values obtained from System properties in static initialiser block
 171      */
 172     public static boolean forcePDL = false;
 173     public static boolean forceRaster = false;
 174     public static boolean shapeTextProp = false;
 175 
 176     static {
 177         /* The system property FORCE_PIPE_PROP
 178          * can be used to force the printing code to
 179          * use a particular pipeline. Either the raster
 180          * pipeline or the pdl pipeline can be forced.
 181          */
 182         String forceStr = java.security.AccessController.doPrivileged(
 183                    new sun.security.action.GetPropertyAction(FORCE_PIPE_PROP));
 184 
 185         if (forceStr != null) {
 186             if (forceStr.equalsIgnoreCase(FORCE_PDL)) {
 187                 forcePDL = true;
 188             } else if (forceStr.equalsIgnoreCase(FORCE_RASTER)) {
 189                 forceRaster = true;
 190             }
 191         }
 192 
 193         String shapeTextStr =java.security.AccessController.doPrivileged(
 194                    new sun.security.action.GetPropertyAction(SHAPE_TEXT_PROP));
 195 
 196         if (shapeTextStr != null) {
 197             shapeTextProp = true;
 198         }
 199     }
 200 
 201     /* Instance Variables */
 202 
 203     /**
 204      * Used to minimize GC & reallocation of band when printing
 205      */
 206     private int cachedBandWidth = 0;
 207     private int cachedBandHeight = 0;
 208     private BufferedImage cachedBand = null;
 209 
 210     /**
 211      * The number of book copies to be printed.
 212      */
 213     private int mNumCopies = 1;
 214 
 215     /**
 216      * Collation effects the order of the pages printed
 217      * when multiple copies are requested. For two copies
 218      * of a three page document the page order is:
 219      *  mCollate true: 1, 2, 3, 1, 2, 3
 220      *  mCollate false: 1, 1, 2, 2, 3, 3
 221      */
 222     private boolean mCollate = false;
 223 
 224     /**
 225      * The zero based indices of the first and last
 226      * pages to be printed. If 'mFirstPage' is
 227      * UNDEFINED_PAGE_NUM then the first page to
 228      * be printed is page 0. If 'mLastPage' is
 229      * UNDEFINED_PAGE_NUM then the last page to
 230      * be printed is the last one in the book.
 231      */
 232     private int mFirstPage = Pageable.UNKNOWN_NUMBER_OF_PAGES;
 233     private int mLastPage = Pageable.UNKNOWN_NUMBER_OF_PAGES;
 234 
 235     /**
 236      * The previous print stream Paper
 237      * Used to check if the paper size has changed such that the
 238      * implementation needs to emit the new paper size information
 239      * into the print stream.
 240      * Since we do our own rotation, and the margins aren't relevant,
 241      * Its strictly the dimensions of the paper that we will check.
 242      */
 243     private Paper previousPaper;
 244 
 245     /**
 246      * The document to be printed. It is initialized to an
 247      * empty (zero pages) book.
 248      */
 249 // MacOSX - made protected so subclasses can reference it.
 250     protected Pageable mDocument = new Book();
 251 
 252     /**
 253      * The name of the job being printed.
 254      */
 255     private String mDocName = "Java Printing";
 256 
 257 
 258     /**
 259      * Printing cancellation flags
 260      */
 261  // MacOSX - made protected so subclasses can reference it.
 262     protected boolean performingPrinting = false;
 263  // MacOSX - made protected so subclasses can reference it.
 264     protected boolean userCancelled = false;
 265 
 266    /**
 267     * Print to file permission variables.
 268     */
 269     private FilePermission printToFilePermission;
 270 
 271     /**
 272      * List of areas & the graphics state for redrawing
 273      */
 274     private ArrayList<GraphicsState> redrawList = new ArrayList<>();
 275 
 276 
 277     /* variables representing values extracted from an attribute set.
 278      * These take precedence over values set on a printer job
 279      */
 280     private int copiesAttr;
 281     private String jobNameAttr;
 282     private String userNameAttr;
 283     private PageRanges pageRangesAttr;
 284     protected PrinterResolution printerResAttr;
 285     protected Sides sidesAttr;
 286     protected String destinationAttr;
 287     protected boolean noJobSheet = false;
 288     protected int mDestType = RasterPrinterJob.FILE;
 289     protected String mDestination = "";
 290     protected boolean collateAttReq = false;
 291 
 292     /**
 293      * Device rotation flag, if it support 270, this is set to true;
 294      */
 295     protected boolean landscapeRotates270 = false;
 296 
 297    /**
 298      * attributes used by no-args page and print dialog and print method to
 299      * communicate state
 300      */
 301     protected PrintRequestAttributeSet attributes = null;
 302 
 303     /**
 304      * Class to keep state information for redrawing areas
 305      * "region" is an area at as a high a resolution as possible.
 306      * The redrawing code needs to look at sx, sy to calculate the scale
 307      * to device resolution.
 308      */
 309     private class GraphicsState {
 310         Rectangle2D region;  // Area of page to repaint
 311         Shape theClip;       // image drawing clip.
 312         AffineTransform theTransform; // to transform clip to dev coords.
 313         double sx;           // X scale from region to device resolution
 314         double sy;           // Y scale from region to device resolution
 315     }
 316 
 317     /**
 318      * Service for this job
 319      */
 320     protected PrintService myService;
 321 
 322  /* Constructors */
 323 
 324     public RasterPrinterJob()
 325     {
 326     }
 327 
 328 /* Abstract Methods */
 329 
 330     /**
 331      * Returns the resolution in dots per inch across the width
 332      * of the page.
 333      */
 334     protected abstract double getXRes();
 335 
 336     /**
 337      * Returns the resolution in dots per inch down the height
 338      * of the page.
 339      */
 340     protected abstract double getYRes();
 341 
 342     /**
 343      * Must be obtained from the current printer.
 344      * Value is in device pixels.
 345      * Not adjusted for orientation of the paper.
 346      */
 347     protected abstract double getPhysicalPrintableX(Paper p);
 348 
 349     /**
 350      * Must be obtained from the current printer.
 351      * Value is in device pixels.
 352      * Not adjusted for orientation of the paper.
 353      */
 354     protected abstract double getPhysicalPrintableY(Paper p);
 355 
 356     /**
 357      * Must be obtained from the current printer.
 358      * Value is in device pixels.
 359      * Not adjusted for orientation of the paper.
 360      */
 361     protected abstract double getPhysicalPrintableWidth(Paper p);
 362 
 363     /**
 364      * Must be obtained from the current printer.
 365      * Value is in device pixels.
 366      * Not adjusted for orientation of the paper.
 367      */
 368     protected abstract double getPhysicalPrintableHeight(Paper p);
 369 
 370     /**
 371      * Must be obtained from the current printer.
 372      * Value is in device pixels.
 373      * Not adjusted for orientation of the paper.
 374      */
 375     protected abstract double getPhysicalPageWidth(Paper p);
 376 
 377     /**
 378      * Must be obtained from the current printer.
 379      * Value is in device pixels.
 380      * Not adjusted for orientation of the paper.
 381      */
 382     protected abstract double getPhysicalPageHeight(Paper p);
 383 
 384     /**
 385      * Begin a new page.
 386      */
 387     protected abstract void startPage(PageFormat format, Printable painter,
 388                                       int index, boolean paperChanged)
 389         throws PrinterException;
 390 
 391     /**
 392      * End a page.
 393      */
 394     protected abstract void endPage(PageFormat format, Printable painter,
 395                                     int index)
 396         throws PrinterException;
 397 
 398     /**
 399      * Prints the contents of the array of ints, 'data'
 400      * to the current page. The band is placed at the
 401      * location (x, y) in device coordinates on the
 402      * page. The width and height of the band is
 403      * specified by the caller.
 404      */
 405     protected abstract void printBand(byte[] data, int x, int y,
 406                                       int width, int height)
 407         throws PrinterException;
 408 
 409 /* Instance Methods */
 410 
 411     /**
 412       * save graphics state of a PathGraphics for later redrawing
 413       * of part of page represented by the region in that state
 414       */
 415 
 416     public void saveState(AffineTransform at, Shape clip,
 417                           Rectangle2D region, double sx, double sy) {
 418         GraphicsState gstate = new GraphicsState();
 419         gstate.theTransform = at;
 420         gstate.theClip = clip;
 421         gstate.region = region;
 422         gstate.sx = sx;
 423         gstate.sy = sy;
 424         redrawList.add(gstate);
 425     }
 426 
 427 
 428     /*
 429      * A convenience method which returns the default service
 430      * for 2D {@code PrinterJob}s.
 431      * May return null if there is no suitable default (although there
 432      * may still be 2D services available).
 433      * @return default 2D print service, or null.
 434      * @since     1.4
 435      */
 436     protected static PrintService lookupDefaultPrintService() {
 437         PrintService service = PrintServiceLookup.lookupDefaultPrintService();
 438 
 439         /* Pageable implies Printable so checking both isn't strictly needed */
 440         if (service != null &&
 441             service.isDocFlavorSupported(
 442                                 DocFlavor.SERVICE_FORMATTED.PAGEABLE) &&
 443             service.isDocFlavorSupported(
 444                                 DocFlavor.SERVICE_FORMATTED.PRINTABLE)) {
 445             return service;
 446         } else {
 447            PrintService []services =
 448              PrintServiceLookup.lookupPrintServices(
 449                                 DocFlavor.SERVICE_FORMATTED.PAGEABLE, null);
 450            if (services.length > 0) {
 451                return services[0];
 452            }
 453         }
 454         return null;
 455     }
 456 
 457    /**
 458      * Returns the service (printer) for this printer job.
 459      * Implementations of this class which do not support print services
 460      * may return null;
 461      * @return the service for this printer job.
 462      *
 463      */
 464     public PrintService getPrintService() {
 465         if (myService == null) {
 466             PrintService svc = PrintServiceLookup.lookupDefaultPrintService();
 467             if (svc != null &&
 468                 svc.isDocFlavorSupported(
 469                      DocFlavor.SERVICE_FORMATTED.PAGEABLE)) {
 470                 try {
 471                     setPrintService(svc);
 472                     myService = svc;
 473                 } catch (PrinterException e) {
 474                 }
 475             }
 476             if (myService == null) {
 477                 PrintService[] svcs = PrintServiceLookup.lookupPrintServices(
 478                     DocFlavor.SERVICE_FORMATTED.PAGEABLE, null);
 479                 if (svcs.length > 0) {
 480                     try {
 481                         setPrintService(svcs[0]);
 482                         myService = svcs[0];
 483                     } catch (PrinterException e) {
 484                     }
 485                 }
 486             }
 487         }
 488         return myService;
 489     }
 490 
 491     /**
 492      * Associate this PrinterJob with a new PrintService.
 493      *
 494      * Throws {@code PrinterException} if the specified service
 495      * cannot support the {@code Pageable} and
 496      * {@code Printable} interfaces necessary to support 2D printing.
 497      * @param service print service which supports 2D printing.
 498      *
 499      * @throws PrinterException if the specified service does not support
 500      * 2D printing or no longer available.
 501      */
 502     public void setPrintService(PrintService service)
 503         throws PrinterException {
 504         if (service == null) {
 505             throw new PrinterException("Service cannot be null");
 506         } else if (!(service instanceof StreamPrintService) &&
 507                    service.getName() == null) {
 508             throw new PrinterException("Null PrintService name.");
 509         } else {
 510             // Check the list of services.  This service may have been
 511             // deleted already
 512             PrinterState prnState = service.getAttribute(PrinterState.class);
 513             if (prnState == PrinterState.STOPPED) {
 514                 PrinterStateReasons prnStateReasons =
 515                     service.getAttribute(PrinterStateReasons.class);
 516                 if ((prnStateReasons != null) &&
 517                     (prnStateReasons.containsKey(PrinterStateReason.SHUTDOWN)))
 518                 {
 519                     throw new PrinterException("PrintService is no longer available.");
 520                 }
 521             }
 522 
 523 
 524             if (service.isDocFlavorSupported(
 525                                              DocFlavor.SERVICE_FORMATTED.PAGEABLE) &&
 526                 service.isDocFlavorSupported(
 527                                              DocFlavor.SERVICE_FORMATTED.PRINTABLE)) {
 528                 myService = service;
 529             } else {
 530                 throw new PrinterException("Not a 2D print service: " + service);
 531             }
 532         }
 533     }
 534 
 535     private PageFormat attributeToPageFormat(PrintService service,
 536                                                PrintRequestAttributeSet attSet) {
 537         PageFormat page = defaultPage();
 538 
 539         if (service == null) {
 540             return page;
 541         }
 542 
 543         OrientationRequested orient = (OrientationRequested)
 544                                       attSet.get(OrientationRequested.class);
 545         if (orient == null) {
 546             orient = (OrientationRequested)
 547                     service.getDefaultAttributeValue(OrientationRequested.class);
 548         }
 549         if (orient == OrientationRequested.REVERSE_LANDSCAPE) {
 550             page.setOrientation(PageFormat.REVERSE_LANDSCAPE);
 551         } else if (orient == OrientationRequested.LANDSCAPE) {
 552             page.setOrientation(PageFormat.LANDSCAPE);
 553         } else {
 554             page.setOrientation(PageFormat.PORTRAIT);
 555         }
 556 
 557         Media media = (Media)attSet.get(Media.class);
 558         MediaSize size = getMediaSize(media, service, page);
 559 
 560         Paper paper = new Paper();
 561         float dim[] = size.getSize(1); //units == 1 to avoid FP error
 562         double w = Math.rint((dim[0]*72.0)/Size2DSyntax.INCH);
 563         double h = Math.rint((dim[1]*72.0)/Size2DSyntax.INCH);
 564         paper.setSize(w, h);
 565         MediaPrintableArea area =
 566              (MediaPrintableArea)
 567              attSet.get(MediaPrintableArea.class);
 568         if (area == null) {
 569             area = getDefaultPrintableArea(page, w, h);
 570         }
 571 
 572         double ix, iw, iy, ih;
 573         // Should pass in same unit as updatePageAttributes
 574         // to avoid rounding off errors.
 575         ix = Math.rint(
 576                 area.getX(MediaPrintableArea.INCH) * DPI);
 577         iy = Math.rint(
 578                 area.getY(MediaPrintableArea.INCH) * DPI);
 579         iw = Math.rint(
 580                 area.getWidth(MediaPrintableArea.INCH) * DPI);
 581         ih = Math.rint(
 582                 area.getHeight(MediaPrintableArea.INCH) * DPI);
 583         paper.setImageableArea(ix, iy, iw, ih);
 584         page.setPaper(paper);
 585         return page;
 586     }
 587     protected MediaSize getMediaSize(Media media, PrintService service,
 588             PageFormat page) {
 589         if (media == null) {
 590             media = (Media)service.getDefaultAttributeValue(Media.class);
 591         }
 592         if (!(media instanceof MediaSizeName)) {
 593             media = MediaSizeName.NA_LETTER;
 594         }
 595         MediaSize size = MediaSize.getMediaSizeForName((MediaSizeName) media);
 596         return size != null ? size : MediaSize.NA.LETTER;
 597     }
 598 
 599     protected MediaPrintableArea getDefaultPrintableArea(PageFormat page,
 600             double w, double h) {
 601         double ix, iw, iy, ih;
 602         if (w >= 72.0 * 6.0) {
 603             ix = 72.0;
 604             iw = w - 2 * 72.0;
 605         } else {
 606             ix = w / 6.0;
 607             iw = w * 0.75;
 608         }
 609         if (h >= 72.0 * 6.0) {
 610             iy = 72.0;
 611             ih = h - 2 * 72.0;
 612         } else {
 613             iy = h / 6.0;
 614             ih = h * 0.75;
 615         }
 616 
 617         return new MediaPrintableArea((float) (ix / DPI), (float) (iy / DPI),
 618                 (float) (iw / DPI), (float) (ih / DPI), MediaPrintableArea.INCH);
 619     }
 620 
 621     protected void updatePageAttributes(PrintService service,
 622                                         PageFormat page) {
 623         if (this.attributes == null) {
 624             this.attributes = new HashPrintRequestAttributeSet();
 625         }
 626 
 627         updateAttributesWithPageFormat(service, page, this.attributes);
 628     }
 629 
 630     protected void updateAttributesWithPageFormat(PrintService service,
 631                                         PageFormat page,
 632                                         PrintRequestAttributeSet pageAttributes) {
 633         if (service == null || page == null || pageAttributes == null) {
 634             return;
 635         }
 636 
 637         float x = (float)Math.rint(
 638                          (page.getPaper().getWidth()*Size2DSyntax.INCH)/
 639                          (72.0))/(float)Size2DSyntax.INCH;
 640         float y = (float)Math.rint(
 641                          (page.getPaper().getHeight()*Size2DSyntax.INCH)/
 642                          (72.0))/(float)Size2DSyntax.INCH;
 643 
 644         // We should limit the list where we search the matching
 645         // media, this will prevent mapping to wrong media ex. Ledger
 646         // can be mapped to B.  Especially useful when creating
 647         // custom MediaSize.
 648         Media[] mediaList = (Media[])service.getSupportedAttributeValues(
 649                                       Media.class, null, null);
 650         Media media = null;
 651         try {
 652             media = CustomMediaSizeName.findMedia(mediaList, x, y,
 653                                    Size2DSyntax.INCH);
 654         } catch (IllegalArgumentException iae) {
 655         }
 656         if ((media == null) ||
 657              !(service.isAttributeValueSupported(media, null, null))) {
 658             media = (Media)service.getDefaultAttributeValue(Media.class);
 659         }
 660 
 661         OrientationRequested orient;
 662         switch (page.getOrientation()) {
 663         case PageFormat.LANDSCAPE :
 664             orient = OrientationRequested.LANDSCAPE;
 665             break;
 666         case PageFormat.REVERSE_LANDSCAPE:
 667             orient = OrientationRequested.REVERSE_LANDSCAPE;
 668             break;
 669         default:
 670             orient = OrientationRequested.PORTRAIT;
 671         }
 672 
 673         if (media != null) {
 674             pageAttributes.add(media);
 675         }
 676         pageAttributes.add(orient);
 677 
 678         float ix = (float)(page.getPaper().getImageableX()/DPI);
 679         float iw = (float)(page.getPaper().getImageableWidth()/DPI);
 680         float iy = (float)(page.getPaper().getImageableY()/DPI);
 681         float ih = (float)(page.getPaper().getImageableHeight()/DPI);
 682 
 683         if (ix < 0) ix = 0; if (iy < 0) iy = 0;
 684         if (iw <= 0) iw = (float)(page.getPaper().getWidth()/DPI) - (ix*2);
 685 
 686         // If iw is still negative, it means ix is too large to print
 687         // anything inside printable area if we have to leave the same margin
 688         // in the right side of paper so we go back to default mpa values
 689         if (iw < 0) iw = 0;
 690 
 691         if (ih <= 0) ih = (float)(page.getPaper().getHeight()/DPI) - (iy*2);
 692 
 693         // If ih is still negative, it means iy is too large to print
 694         // anything inside printable area if we have to leave the same margin
 695         // in the bottom side of paper so we go back to default mpa values
 696         if (ih < 0) ih = 0;
 697         try {
 698             pageAttributes.add(new MediaPrintableArea(ix, iy, iw, ih,
 699                                                   MediaPrintableArea.INCH));
 700         } catch (IllegalArgumentException iae) {
 701         }
 702     }
 703 
 704    /**
 705      * Display a dialog to the user allowing the modification of a
 706      * PageFormat instance.
 707      * The {@code page} argument is used to initialize controls
 708      * in the page setup dialog.
 709      * If the user cancels the dialog, then the method returns the
 710      * original {@code page} object unmodified.
 711      * If the user okays the dialog then the method returns a new
 712      * PageFormat object with the indicated changes.
 713      * In either case the original {@code page} object will
 714      * not be modified.
 715      * @param     page    the default PageFormat presented to the user
 716      *                    for modification
 717      * @return    the original {@code page} object if the dialog
 718      *            is cancelled, or a new PageFormat object containing
 719      *            the format indicated by the user if the dialog is
 720      *            acknowledged
 721      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 722      * returns true.
 723      * @see java.awt.GraphicsEnvironment#isHeadless
 724      * @since     1.2
 725      */
 726     public PageFormat pageDialog(PageFormat page)
 727         throws HeadlessException {
 728         if (GraphicsEnvironment.isHeadless()) {
 729             throw new HeadlessException();
 730         }
 731 
 732         final GraphicsConfiguration gc =
 733           GraphicsEnvironment.getLocalGraphicsEnvironment().
 734           getDefaultScreenDevice().getDefaultConfiguration();
 735 
 736         PrintService service = java.security.AccessController.doPrivileged(
 737                                new java.security.PrivilegedAction<PrintService>() {
 738                 public PrintService run() {
 739                     PrintService service = getPrintService();
 740                     if (service == null) {
 741                         ServiceDialog.showNoPrintService(gc);
 742                         return null;
 743                     }
 744                     return service;
 745                 }
 746             });
 747 
 748         if (service == null) {
 749             return page;
 750         }
 751         updatePageAttributes(service, page);
 752 
 753         PageFormat newPage = null;
 754         DialogTypeSelection dts =
 755             (DialogTypeSelection)attributes.get(DialogTypeSelection.class);
 756         if (dts == DialogTypeSelection.NATIVE) {
 757             // Remove DialogTypeSelection.NATIVE to prevent infinite loop in
 758             // RasterPrinterJob.
 759             attributes.remove(DialogTypeSelection.class);
 760             newPage = pageDialog(attributes);
 761             // restore attribute
 762             attributes.add(DialogTypeSelection.NATIVE);
 763         } else {
 764             newPage = pageDialog(attributes);
 765         }
 766 
 767         if (newPage == null) {
 768             return page;
 769         } else {
 770             return newPage;
 771         }
 772     }
 773 
 774     /**
 775      * return a PageFormat corresponding to the updated attributes,
 776      * or null if the user cancelled the dialog.
 777      */
 778     @SuppressWarnings("deprecation")
 779     public PageFormat pageDialog(final PrintRequestAttributeSet attributes)
 780         throws HeadlessException {
 781         if (GraphicsEnvironment.isHeadless()) {
 782             throw new HeadlessException();
 783         }
 784 
 785         DialogTypeSelection dlg =
 786             (DialogTypeSelection)attributes.get(DialogTypeSelection.class);
 787 
 788         // Check for native, note that default dialog is COMMON.
 789         if (dlg == DialogTypeSelection.NATIVE) {
 790             PrintService pservice = getPrintService();
 791             PageFormat pageFrmAttrib = attributeToPageFormat(pservice,
 792                                                              attributes);
 793             PageFormat page = pageDialog(pageFrmAttrib);
 794 
 795             // If user cancels the dialog, pageDialog() will return the original
 796             // page object and as per spec, we should return null in that case.
 797             if (page == pageFrmAttrib) {
 798                 return null;
 799             }
 800             updateAttributesWithPageFormat(pservice, page, attributes);
 801             return page;
 802         }
 803 
 804         GraphicsConfiguration grCfg = null;
 805         Window w = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
 806         if (w != null) {
 807             grCfg = w.getGraphicsConfiguration();
 808         } else {
 809             grCfg = GraphicsEnvironment.getLocalGraphicsEnvironment().
 810                         getDefaultScreenDevice().getDefaultConfiguration();
 811         }
 812         final GraphicsConfiguration gc = grCfg;
 813 
 814         PrintService service = java.security.AccessController.doPrivileged(
 815                                new java.security.PrivilegedAction<PrintService>() {
 816                 public PrintService run() {
 817                     PrintService service = getPrintService();
 818                     if (service == null) {
 819                         ServiceDialog.showNoPrintService(gc);
 820                         return null;
 821                     }
 822                     return service;
 823                 }
 824             });
 825 
 826         if (service == null) {
 827             return null;
 828         }
 829 
 830         // we position the dialog a little beyond the upper-left corner of the window
 831         // which is consistent with the NATIVE page dialog
 832         Rectangle gcBounds = gc.getBounds();
 833         int x = gcBounds.x+50;
 834         int y = gcBounds.y+50;
 835         ServiceDialog pageDialog;
 836         if (w instanceof Frame) {
 837             pageDialog = new ServiceDialog(gc, x, y, service,
 838                                        DocFlavor.SERVICE_FORMATTED.PAGEABLE,
 839                                        attributes, (Frame)w);
 840         } else {
 841             pageDialog = new ServiceDialog(gc, x, y, service,
 842                                        DocFlavor.SERVICE_FORMATTED.PAGEABLE,
 843                                        attributes, (Dialog)w);
 844         }
 845         Rectangle dlgBounds = pageDialog.getBounds();
 846 
 847         // if portion of dialog is not within the gc boundary
 848         if (!gcBounds.contains(dlgBounds)) {
 849             // check if dialog exceed window bounds at left or bottom
 850             // Then position the dialog by moving it by the amount it exceeds
 851             // the window bounds
 852             // If it results in dialog moving beyond the window bounds at top/left
 853             // then position it at window top/left
 854             if (dlgBounds.x + dlgBounds.width > gcBounds.x + gcBounds.width) {
 855                 if ((gcBounds.x + gcBounds.width - dlgBounds.width) > gcBounds.x) {
 856                     x = (gcBounds.x + gcBounds.width) - dlgBounds.width;
 857                 } else {
 858                     x = gcBounds.x;
 859                 }
 860             }
 861             if (dlgBounds.y + dlgBounds.height > gcBounds.y + gcBounds.height) {
 862                 if ((gcBounds.y + gcBounds.height - dlgBounds.height) > gcBounds.y) {
 863                     y = (gcBounds.y + gcBounds.height) - dlgBounds.height;
 864                 } else {
 865                     y = gcBounds.y;
 866                 }
 867             }
 868             pageDialog.setBounds(x, y, dlgBounds.width, dlgBounds.height);
 869         }
 870         pageDialog.show();
 871 
 872         if (pageDialog.getStatus() == ServiceDialog.APPROVE) {
 873             PrintRequestAttributeSet newas =
 874                 pageDialog.getAttributes();
 875             Class<?> amCategory = SunAlternateMedia.class;
 876 
 877             if (attributes.containsKey(amCategory) &&
 878                 !newas.containsKey(amCategory)) {
 879                 attributes.remove(amCategory);
 880             }
 881             attributes.addAll(newas);
 882             return attributeToPageFormat(service, attributes);
 883         } else {
 884             return null;
 885         }
 886    }
 887 
 888    protected PageFormat getPageFormatFromAttributes() {
 889        if (attributes == null || attributes.isEmpty()) {
 890             return null;
 891         }
 892         return attributeToPageFormat(getPrintService(), this.attributes);
 893    }
 894 
 895 
 896    /**
 897      * Presents the user a dialog for changing properties of the
 898      * print job interactively.
 899      * The services browsable here are determined by the type of
 900      * service currently installed.
 901      * If the application installed a StreamPrintService on this
 902      * PrinterJob, only the available StreamPrintService (factories) are
 903      * browsable.
 904      *
 905      * @param attributes to store changed properties.
 906      * @return false if the user cancels the dialog and true otherwise.
 907      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 908      * returns true.
 909      * @see java.awt.GraphicsEnvironment#isHeadless
 910      */
 911     public boolean printDialog(final PrintRequestAttributeSet attributes)
 912         throws HeadlessException {
 913         if (GraphicsEnvironment.isHeadless()) {
 914             throw new HeadlessException();
 915         }
 916 
 917         DialogTypeSelection dlg =
 918             (DialogTypeSelection)attributes.get(DialogTypeSelection.class);
 919 
 920         // Check for native, note that default dialog is COMMON.
 921         if (dlg == DialogTypeSelection.NATIVE) {
 922             this.attributes = attributes;
 923             try {
 924                 debug_println("calling setAttributes in printDialog");
 925                 setAttributes(attributes);
 926 
 927             } catch (PrinterException e) {
 928 
 929             }
 930 
 931             boolean ret = printDialog();
 932             this.attributes = attributes;
 933             return ret;
 934 
 935         }
 936 
 937         /* A security check has already been performed in the
 938          * java.awt.print.printerJob.getPrinterJob method.
 939          * So by the time we get here, it is OK for the current thread
 940          * to print either to a file (from a Dialog we control!) or
 941          * to a chosen printer.
 942          *
 943          * We raise privilege when we put up the dialog, to avoid
 944          * the "warning applet window" banner.
 945          */
 946         GraphicsConfiguration grCfg = null;
 947         Window w = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
 948         if (w != null) {
 949             grCfg = w.getGraphicsConfiguration();
 950             /* Add DialogOwner attribute to set the owner of this print dialog
 951              * only if it is not set already 
 952              * (it might be set in java.awt.PrintJob.printDialog)
 953              */
 954             if (attributes.get(DialogOwner.class) == null) {
 955                 if (w instanceof Frame) {
 956                     attributes.add(new DialogOwner((Frame)w));
 957                 } else if (w instanceof Dialog) {
 958                     attributes.add(new DialogOwner((Dialog)w));
 959                 }
 960             }            
 961         } else {
 962             grCfg = GraphicsEnvironment.getLocalGraphicsEnvironment().
 963                         getDefaultScreenDevice().getDefaultConfiguration();
 964         }
 965         final GraphicsConfiguration gc = grCfg;
 966 
 967         PrintService service = java.security.AccessController.doPrivileged(
 968                                new java.security.PrivilegedAction<PrintService>() {
 969                 public PrintService run() {
 970                     PrintService service = getPrintService();
 971                     if (service == null) {
 972                         ServiceDialog.showNoPrintService(gc);
 973                         return null;
 974                     }
 975                     return service;
 976                 }
 977             });
 978 
 979         if (service == null) {
 980             return false;
 981         }
 982 
 983         PrintService[] services;
 984         StreamPrintServiceFactory[] spsFactories = null;
 985         if (service instanceof StreamPrintService) {
 986             spsFactories = lookupStreamPrintServices(null);
 987             services = new StreamPrintService[spsFactories.length];
 988             for (int i=0; i<spsFactories.length; i++) {
 989                 services[i] = spsFactories[i].getPrintService(null);
 990             }
 991         } else {
 992             services = java.security.AccessController.doPrivileged(
 993                        new java.security.PrivilegedAction<PrintService[]>() {
 994                 public PrintService[] run() {
 995                     PrintService[] services = PrinterJob.lookupPrintServices();
 996                     return services;
 997                 }
 998             });
 999 
1000             if ((services == null) || (services.length == 0)) {
1001                 /*
1002                  * No services but default PrintService exists?
1003                  * Create services using defaultService.
1004                  */
1005                 services = new PrintService[1];
1006                 services[0] = service;
1007             }
1008         }
1009 
1010         // we position the dialog a little beyond the upper-left corner of the window
1011         // which is consistent with the NATIVE print dialog
1012         int x = 50;
1013         int y = 50;
1014         PrintService newService;
1015         // temporarily add an attribute pointing back to this job.
1016         PrinterJobWrapper jobWrapper = new PrinterJobWrapper(this);
1017         attributes.add(jobWrapper);
1018         try {
1019             newService =
1020             ServiceUI.printDialog(gc, x, y,
1021                                   services, service,
1022                                   DocFlavor.SERVICE_FORMATTED.PAGEABLE,
1023                                   attributes);
1024         } catch (IllegalArgumentException iae) {
1025             newService = ServiceUI.printDialog(gc, x, y,
1026                                   services, services[0],
1027                                   DocFlavor.SERVICE_FORMATTED.PAGEABLE,
1028                                   attributes);
1029         }
1030         attributes.remove(PrinterJobWrapper.class);
1031 
1032         if (newService == null) {
1033             return false;
1034         }
1035 
1036         if (!service.equals(newService)) {
1037             try {
1038                 setPrintService(newService);
1039             } catch (PrinterException e) {
1040                 /*
1041                  * The only time it would throw an exception is when
1042                  * newService is no longer available but we should still
1043                  * select this printer.
1044                  */
1045                 myService = newService;
1046             }
1047         }
1048         return true;
1049     }
1050 
1051    /**
1052      * Presents the user a dialog for changing properties of the
1053      * print job interactively.
1054      * @return false if the user cancels the dialog and
1055      *         true otherwise.
1056      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1057      * returns true.
1058      * @see java.awt.GraphicsEnvironment#isHeadless
1059      */
1060     public boolean printDialog() throws HeadlessException {
1061 
1062         if (GraphicsEnvironment.isHeadless()) {
1063             throw new HeadlessException();
1064         }
1065 
1066         PrintRequestAttributeSet attributes =
1067           new HashPrintRequestAttributeSet();
1068         attributes.add(new Copies(getCopies()));
1069         attributes.add(new JobName(getJobName(), null));
1070         boolean doPrint = printDialog(attributes);
1071         if (doPrint) {
1072             JobName jobName = (JobName)attributes.get(JobName.class);
1073             if (jobName != null) {
1074                 setJobName(jobName.getValue());
1075             }
1076             Copies copies = (Copies)attributes.get(Copies.class);
1077             if (copies != null) {
1078                 setCopies(copies.getValue());
1079             }
1080 
1081             Destination dest = (Destination)attributes.get(Destination.class);
1082 
1083             if (dest != null) {
1084                 try {
1085                     mDestType = RasterPrinterJob.FILE;
1086                     mDestination = (new File(dest.getURI())).getPath();
1087                 } catch (Exception e) {
1088                     mDestination = "out.prn";
1089                     PrintService ps = getPrintService();
1090                     if (ps != null) {
1091                         Destination defaultDest = (Destination)ps.
1092                             getDefaultAttributeValue(Destination.class);
1093                         if (defaultDest != null) {
1094                             mDestination = (new File(defaultDest.getURI())).getPath();
1095                         }
1096                     }
1097                 }
1098             } else {
1099                 mDestType = RasterPrinterJob.PRINTER;
1100                 PrintService ps = getPrintService();
1101                 if (ps != null) {
1102                     mDestination = ps.getName();
1103                 }
1104             }
1105         }
1106 
1107         return doPrint;
1108     }
1109 
1110     /**
1111      * The pages in the document to be printed by this PrinterJob
1112      * are drawn by the Printable object 'painter'. The PageFormat
1113      * for each page is the default page format.
1114      * @param painter Called to render each page of the document.
1115      */
1116     public void setPrintable(Printable painter) {
1117         setPageable(new OpenBook(defaultPage(new PageFormat()), painter));
1118     }
1119 
1120     /**
1121      * The pages in the document to be printed by this PrinterJob
1122      * are drawn by the Printable object 'painter'. The PageFormat
1123      * of each page is 'format'.
1124      * @param painter Called to render each page of the document.
1125      * @param format  The size and orientation of each page to
1126      *                be printed.
1127      */
1128     public void setPrintable(Printable painter, PageFormat format) {
1129         setPageable(new OpenBook(format, painter));
1130         updatePageAttributes(getPrintService(), format);
1131     }
1132 
1133     /**
1134      * The pages in the document to be printed are held by the
1135      * Pageable instance 'document'. 'document' will be queried
1136      * for the number of pages as well as the PageFormat and
1137      * Printable for each page.
1138      * @param document The document to be printed. It may not be null.
1139      * @exception NullPointerException the Pageable passed in was null.
1140      * @see PageFormat
1141      * @see Printable
1142      */
1143     public void setPageable(Pageable document) throws NullPointerException {
1144         if (document != null) {
1145             mDocument = document;
1146 
1147         } else {
1148             throw new NullPointerException();
1149         }
1150     }
1151 
1152     protected void initPrinter() {
1153         return;
1154     }
1155 
1156     protected boolean isSupportedValue(Attribute attrval,
1157                                      PrintRequestAttributeSet attrset) {
1158         PrintService ps = getPrintService();
1159         return
1160             (attrval != null && ps != null &&
1161              ps.isAttributeValueSupported(attrval,
1162                                           DocFlavor.SERVICE_FORMATTED.PAGEABLE,
1163                                           attrset));
1164     }
1165 
1166     /**
1167      * Set the device resolution.
1168      * Overridden and used only by the postscript code.
1169      * Windows code pulls the information from the attribute set itself.
1170      */
1171     protected void setXYRes(double x, double y) {
1172     }
1173 
1174     /* subclasses may need to pull extra information out of the attribute set
1175      * They can override this method & call super.setAttributes()
1176      */
1177     protected  void setAttributes(PrintRequestAttributeSet attributes)
1178         throws PrinterException {
1179         /*  reset all values to defaults */
1180         setCollated(false);
1181         sidesAttr = null;
1182         printerResAttr = null;
1183         pageRangesAttr = null;
1184         copiesAttr = 0;
1185         jobNameAttr = null;
1186         userNameAttr = null;
1187         destinationAttr = null;
1188         collateAttReq = false;
1189 
1190         PrintService service = getPrintService();
1191         if (attributes == null  || service == null) {
1192             return;
1193         }
1194 
1195         boolean fidelity = false;
1196         Fidelity attrFidelity = (Fidelity)attributes.get(Fidelity.class);
1197         if (attrFidelity != null && attrFidelity == Fidelity.FIDELITY_TRUE) {
1198             fidelity = true;
1199         }
1200 
1201         if (fidelity == true) {
1202            AttributeSet unsupported =
1203                service.getUnsupportedAttributes(
1204                                          DocFlavor.SERVICE_FORMATTED.PAGEABLE,
1205                                          attributes);
1206            if (unsupported != null) {
1207                throw new PrinterException("Fidelity cannot be satisfied");
1208            }
1209         }
1210 
1211         /*
1212          * Since we have verified supported values if fidelity is true,
1213          * we can either ignore unsupported values, or substitute a
1214          * reasonable alternative
1215          */
1216 
1217         SheetCollate collateAttr =
1218             (SheetCollate)attributes.get(SheetCollate.class);
1219         if (isSupportedValue(collateAttr,  attributes)) {
1220             setCollated(collateAttr == SheetCollate.COLLATED);
1221         }
1222 
1223         sidesAttr = (Sides)attributes.get(Sides.class);
1224         if (!isSupportedValue(sidesAttr,  attributes)) {
1225             sidesAttr = Sides.ONE_SIDED;
1226         }
1227 
1228         printerResAttr = (PrinterResolution)attributes.get(PrinterResolution.class);
1229         if (service.isAttributeCategorySupported(PrinterResolution.class)) {
1230             if (!isSupportedValue(printerResAttr,  attributes)) {
1231                printerResAttr = (PrinterResolution)
1232                    service.getDefaultAttributeValue(PrinterResolution.class);
1233             }
1234             double xr =
1235                printerResAttr.getCrossFeedResolution(ResolutionSyntax.DPI);
1236             double yr = printerResAttr.getFeedResolution(ResolutionSyntax.DPI);
1237             setXYRes(xr, yr);
1238         }
1239 
1240         pageRangesAttr =  (PageRanges)attributes.get(PageRanges.class);
1241         if (!isSupportedValue(pageRangesAttr, attributes)) {
1242             pageRangesAttr = null;
1243             setPageRange(-1, -1);
1244         } else {
1245             if ((SunPageSelection)attributes.get(SunPageSelection.class)
1246                      == SunPageSelection.RANGE) {
1247                 // get to, from, min, max page ranges
1248                 int[][] range = pageRangesAttr.getMembers();
1249                 // setPageRanges uses 0-based indexing so we subtract 1
1250                 setPageRange(range[0][0] - 1, range[0][1] - 1);
1251             } else {
1252                setPageRange(-1, - 1);
1253             }
1254         }
1255 
1256         Copies copies = (Copies)attributes.get(Copies.class);
1257         if (isSupportedValue(copies,  attributes) ||
1258             (!fidelity && copies != null)) {
1259             copiesAttr = copies.getValue();
1260             setCopies(copiesAttr);
1261         } else {
1262             copiesAttr = getCopies();
1263         }
1264 
1265         Destination destination =
1266             (Destination)attributes.get(Destination.class);
1267 
1268         if (isSupportedValue(destination,  attributes)) {
1269             try {
1270                 // Old code (new File(destination.getURI())).getPath()
1271                 // would generate a "URI is not hierarchical" IAE
1272                 // for "file:out.prn" so we use getSchemeSpecificPart instead
1273                 destinationAttr = "" + new File(destination.getURI().
1274                                                 getSchemeSpecificPart());
1275             } catch (Exception e) { // paranoid exception
1276                 Destination defaultDest = (Destination)service.
1277                     getDefaultAttributeValue(Destination.class);
1278                 if (defaultDest != null) {
1279                     destinationAttr = "" + new File(defaultDest.getURI().
1280                                                 getSchemeSpecificPart());
1281                 }
1282             }
1283         }
1284 
1285         JobSheets jobSheets = (JobSheets)attributes.get(JobSheets.class);
1286         if (jobSheets != null) {
1287             noJobSheet = jobSheets == JobSheets.NONE;
1288         } else {
1289             JobSheets js = (JobSheets)getPrintService().
1290                                       getDefaultAttributeValue(JobSheets.class);
1291             if (js != null && js.equals(JobSheets.NONE)) {
1292                 noJobSheet = true;
1293             }
1294         }
1295 
1296         JobName jobName = (JobName)attributes.get(JobName.class);
1297         if (isSupportedValue(jobName,  attributes) ||
1298             (!fidelity && jobName != null)) {
1299             jobNameAttr = jobName.getValue();
1300             setJobName(jobNameAttr);
1301         } else {
1302             jobNameAttr = getJobName();
1303         }
1304 
1305         RequestingUserName userName =
1306             (RequestingUserName)attributes.get(RequestingUserName.class);
1307         if (isSupportedValue(userName,  attributes) ||
1308             (!fidelity && userName != null)) {
1309             userNameAttr = userName.getValue();
1310         } else {
1311             try {
1312                 userNameAttr = getUserName();
1313             } catch (SecurityException e) {
1314                 userNameAttr = "";
1315             }
1316         }
1317 
1318         /* OpenBook is used internally only when app uses Printable.
1319          * This is the case when we use the values from the attribute set.
1320          */
1321         Media media = (Media)attributes.get(Media.class);
1322         OrientationRequested orientReq =
1323            (OrientationRequested)attributes.get(OrientationRequested.class);
1324         MediaPrintableArea mpa =
1325             (MediaPrintableArea)attributes.get(MediaPrintableArea.class);
1326 
1327         if ((orientReq != null || media != null || mpa != null) &&
1328             getPageable() instanceof OpenBook) {
1329 
1330             /* We could almost(!) use PrinterJob.getPageFormat() except
1331              * here we need to start with the PageFormat from the OpenBook :
1332              */
1333             Pageable pageable = getPageable();
1334             Printable printable = pageable.getPrintable(0);
1335             PageFormat pf = (PageFormat)pageable.getPageFormat(0).clone();
1336             Paper paper = pf.getPaper();
1337 
1338             /* If there's a media but no media printable area, we can try
1339              * to retrieve the default value for mpa and use that.
1340              */
1341             if (mpa == null && media != null &&
1342                 service.
1343                 isAttributeCategorySupported(MediaPrintableArea.class)) {
1344                 Object mpaVals = service.
1345                     getSupportedAttributeValues(MediaPrintableArea.class,
1346                                                 null, attributes);
1347                 if (mpaVals instanceof MediaPrintableArea[] &&
1348                     ((MediaPrintableArea[])mpaVals).length > 0) {
1349                     mpa = ((MediaPrintableArea[])mpaVals)[0];
1350                 }
1351             }
1352 
1353             if (isSupportedValue(orientReq, attributes) ||
1354                 (!fidelity && orientReq != null)) {
1355                 int orient;
1356                 if (orientReq.equals(OrientationRequested.REVERSE_LANDSCAPE)) {
1357                     orient = PageFormat.REVERSE_LANDSCAPE;
1358                 } else if (orientReq.equals(OrientationRequested.LANDSCAPE)) {
1359                     orient = PageFormat.LANDSCAPE;
1360                 } else {
1361                     orient = PageFormat.PORTRAIT;
1362                 }
1363                 pf.setOrientation(orient);
1364             }
1365 
1366             if (isSupportedValue(media, attributes) ||
1367                 (!fidelity && media != null)) {
1368                 if (media instanceof MediaSizeName) {
1369                     MediaSizeName msn = (MediaSizeName)media;
1370                     MediaSize msz = MediaSize.getMediaSizeForName(msn);
1371                     if (msz != null) {
1372                         float paperWid =  msz.getX(MediaSize.INCH) * 72.0f;
1373                         float paperHgt =  msz.getY(MediaSize.INCH) * 72.0f;
1374                         paper.setSize(paperWid, paperHgt);
1375                         if (mpa == null) {
1376                             paper.setImageableArea(72.0, 72.0,
1377                                                    paperWid-144.0,
1378                                                    paperHgt-144.0);
1379                         }
1380                     }
1381                 }
1382             }
1383 
1384             if (isSupportedValue(mpa, attributes) ||
1385                 (!fidelity && mpa != null)) {
1386                 float [] printableArea =
1387                     mpa.getPrintableArea(MediaPrintableArea.INCH);
1388                 for (int i=0; i < printableArea.length; i++) {
1389                     printableArea[i] = printableArea[i]*72.0f;
1390                 }
1391                 paper.setImageableArea(printableArea[0], printableArea[1],
1392                                        printableArea[2], printableArea[3]);
1393             }
1394 
1395             pf.setPaper(paper);
1396             pf = validatePage(pf);
1397             setPrintable(printable, pf);
1398         } else {
1399             // for AWT where pageable is not an instance of OpenBook,
1400             // we need to save paper info
1401             this.attributes = attributes;
1402         }
1403 
1404     }
1405 
1406     /*
1407      * Services we don't recognize as built-in services can't be
1408      * implemented as subclasses of PrinterJob, therefore we create
1409      * a DocPrintJob from their service and pass a Doc representing
1410      * the application's printjob
1411      */
1412 // MacOSX - made protected so subclasses can reference it.
1413     protected void spoolToService(PrintService psvc,
1414                                 PrintRequestAttributeSet attributes)
1415         throws PrinterException {
1416 
1417         if (psvc == null) {
1418             throw new PrinterException("No print service found.");
1419         }
1420 
1421         DocPrintJob job = psvc.createPrintJob();
1422         Doc doc = new PageableDoc(getPageable());
1423         if (attributes == null) {
1424             attributes = new HashPrintRequestAttributeSet();
1425             attributes.add(new Copies(getCopies()));
1426             attributes.add(new JobName(getJobName(), null));
1427         }
1428         try {
1429             job.print(doc, attributes);
1430         } catch (PrintException e) {
1431             throw new PrinterException(e.toString());
1432         }
1433     }
1434 
1435     /**
1436      * Prints a set of pages.
1437      * @exception java.awt.print.PrinterException an error in the print system
1438      *                                          caused the job to be aborted
1439      * @see java.awt.print.Book
1440      * @see java.awt.print.Pageable
1441      * @see java.awt.print.Printable
1442      */
1443     public void print() throws PrinterException {
1444         print(attributes);
1445     }
1446 
1447     public static boolean debugPrint = false;
1448     protected void debug_println(String str) {
1449         if (debugPrint) {
1450             System.out.println("RasterPrinterJob "+str+" "+this);
1451         }
1452     }
1453 
1454     public void print(PrintRequestAttributeSet attributes)
1455         throws PrinterException {
1456 
1457         /*
1458          * In the future PrinterJob will probably always dispatch
1459          * the print job to the PrintService.
1460          * This is how third party 2D Print Services will be invoked
1461          * when applications use the PrinterJob API.
1462          * However the JRE's concrete PrinterJob implementations have
1463          * not yet been re-worked to be implemented as standalone
1464          * services, and are implemented only as subclasses of PrinterJob.
1465          * So here we dispatch only those services we do not recognize
1466          * as implemented through platform subclasses of PrinterJob
1467          * (and this class).
1468          */
1469         PrintService psvc = getPrintService();
1470         debug_println("psvc = "+psvc);
1471         if (psvc == null) {
1472             throw new PrinterException("No print service found.");
1473         }
1474 
1475         // Check the list of services.  This service may have been
1476         // deleted already
1477         PrinterState prnState = psvc.getAttribute(PrinterState.class);
1478         if (prnState == PrinterState.STOPPED) {
1479             PrinterStateReasons prnStateReasons =
1480                     psvc.getAttribute(PrinterStateReasons.class);
1481                 if ((prnStateReasons != null) &&
1482                     (prnStateReasons.containsKey(PrinterStateReason.SHUTDOWN)))
1483                 {
1484                     throw new PrinterException("PrintService is no longer available.");
1485                 }
1486         }
1487 
1488         if ((psvc.getAttribute(PrinterIsAcceptingJobs.class)) ==
1489                          PrinterIsAcceptingJobs.NOT_ACCEPTING_JOBS) {
1490             throw new PrinterException("Printer is not accepting job.");
1491         }
1492 
1493         if ((psvc instanceof SunPrinterJobService) &&
1494             ((SunPrinterJobService)psvc).usesClass(getClass())) {
1495             setAttributes(attributes);
1496             // throw exception for invalid destination
1497             if (destinationAttr != null) {
1498                 validateDestination(destinationAttr);
1499             }
1500         } else {
1501             spoolToService(psvc, attributes);
1502             return;
1503         }
1504         /* We need to make sure that the collation and copies
1505          * settings are initialised */
1506         initPrinter();
1507 
1508         int numCollatedCopies = getCollatedCopies();
1509         int numNonCollatedCopies = getNoncollatedCopies();
1510         debug_println("getCollatedCopies()  "+numCollatedCopies
1511               + " getNoncollatedCopies() "+ numNonCollatedCopies);
1512 
1513         /* Get the range of pages we are to print. If the
1514          * last page to print is unknown, then we print to
1515          * the end of the document. Note that firstPage
1516          * and lastPage are 0 based page indices.
1517          */
1518         int numPages = mDocument.getNumberOfPages();
1519         if (numPages == 0) {
1520             return;
1521         }
1522 
1523         int firstPage = getFirstPage();
1524         int lastPage = getLastPage();
1525         if(lastPage == Pageable.UNKNOWN_NUMBER_OF_PAGES){
1526             int totalPages = mDocument.getNumberOfPages();
1527             if (totalPages != Pageable.UNKNOWN_NUMBER_OF_PAGES) {
1528                 lastPage = mDocument.getNumberOfPages() - 1;
1529             }
1530         }
1531 
1532         try {
1533             synchronized (this) {
1534                 performingPrinting = true;
1535                 userCancelled = false;
1536             }
1537 
1538             startDoc();
1539             if (isCancelled()) {
1540                 cancelDoc();
1541             }
1542 
1543             // PageRanges can be set even if RANGE is not selected
1544             // so we need to check if it is selected.
1545             boolean rangeIsSelected = true;
1546             if (attributes != null) {
1547                 SunPageSelection pages =
1548                     (SunPageSelection)attributes.get(SunPageSelection.class);
1549                 if ((pages != null) && (pages != SunPageSelection.RANGE)) {
1550                     rangeIsSelected = false;
1551                 }
1552             }
1553 
1554 
1555             debug_println("after startDoc rangeSelected? "+rangeIsSelected
1556                       + " numNonCollatedCopies "+ numNonCollatedCopies);
1557 
1558 
1559             /* Three nested loops iterate over the document. The outer loop
1560              * counts the number of collated copies while the inner loop
1561              * counts the number of nonCollated copies. Normally, one of
1562              * these two loops will only execute once; that is we will
1563              * either print collated copies or noncollated copies. The
1564              * middle loop iterates over the pages.
1565              * If a PageRanges attribute is used, it constrains the pages
1566              * that are imaged. If a platform subclass (though a user dialog)
1567              * requests a page range via setPageRange(). it too can
1568              * constrain the page ranges that are imaged.
1569              * It is expected that only one of these will be used in a
1570              * job but both should be able to co-exist.
1571              */
1572             for(int collated = 0; collated < numCollatedCopies; collated++) {
1573                 for(int i = firstPage, pageResult = Printable.PAGE_EXISTS;
1574                     (i <= lastPage ||
1575                      lastPage == Pageable.UNKNOWN_NUMBER_OF_PAGES)
1576                     && pageResult == Printable.PAGE_EXISTS;
1577                     i++)
1578                 {
1579 
1580                     if ((pageRangesAttr != null) && rangeIsSelected ){
1581                         int nexti = pageRangesAttr.next(i);
1582                         if (nexti == -1) {
1583                             break;
1584                         } else if (nexti != i+1) {
1585                             continue;
1586                         }
1587                     }
1588 
1589                     for(int nonCollated = 0;
1590                         nonCollated < numNonCollatedCopies
1591                         && pageResult == Printable.PAGE_EXISTS;
1592                         nonCollated++)
1593                     {
1594                         if (isCancelled()) {
1595                             cancelDoc();
1596                         }
1597                         debug_println("printPage "+i);
1598                         pageResult = printPage(mDocument, i);
1599 
1600                     }
1601                 }
1602             }
1603 
1604             if (isCancelled()) {
1605                 cancelDoc();
1606             }
1607 
1608         } finally {
1609             // reset previousPaper in case this job is invoked again.
1610             previousPaper = null;
1611             synchronized (this) {
1612                 if (performingPrinting) {
1613                     endDoc();
1614                 }
1615                 performingPrinting = false;
1616                 notify();
1617             }
1618         }
1619     }
1620 
1621     protected void validateDestination(String dest) throws PrinterException {
1622         if (dest == null) {
1623             return;
1624         }
1625         // dest is null for Destination(new URI(""))
1626         // because isAttributeValueSupported returns false in setAttributes
1627 
1628         // Destination(new URI(" ")) throws URISyntaxException
1629         File f = new File(dest);
1630         try {
1631             // check if this is a new file and if filename chars are valid
1632             if (f.createNewFile()) {
1633                 f.delete();
1634             }
1635         } catch (IOException ioe) {
1636             throw new PrinterException("Cannot write to file:"+
1637                                        dest);
1638         } catch (SecurityException se) {
1639             //There is already file read/write access so at this point
1640             // only delete access is denied.  Just ignore it because in
1641             // most cases the file created in createNewFile gets overwritten
1642             // anyway.
1643         }
1644 
1645         File pFile = f.getParentFile();
1646         if ((f.exists() &&
1647              (!f.isFile() || !f.canWrite())) ||
1648             ((pFile != null) &&
1649              (!pFile.exists() || (pFile.exists() && !pFile.canWrite())))) {
1650             if (f.exists()) {
1651                 f.delete();
1652             }
1653             throw new PrinterException("Cannot write to file:"+
1654                                        dest);
1655         }
1656     }
1657 
1658     /**
1659      * updates a Paper object to reflect the current printer's selected
1660      * paper size and imageable area for that paper size.
1661      * Default implementation copies settings from the original, applies
1662      * applies some validity checks, changes them only if they are
1663      * clearly unreasonable, then sets them into the new Paper.
1664      * Subclasses are expected to override this method to make more
1665      * informed decisons.
1666      */
1667     protected void validatePaper(Paper origPaper, Paper newPaper) {
1668         if (origPaper == null || newPaper == null) {
1669             return;
1670         } else {
1671             double wid = origPaper.getWidth();
1672             double hgt = origPaper.getHeight();
1673             double ix = origPaper.getImageableX();
1674             double iy = origPaper.getImageableY();
1675             double iw = origPaper.getImageableWidth();
1676             double ih = origPaper.getImageableHeight();
1677 
1678             /* Assume any +ve values are legal. Overall paper dimensions
1679              * take precedence. Make sure imageable area fits on the paper.
1680              */
1681             Paper defaultPaper = new Paper();
1682             wid = ((wid > 0.0) ? wid : defaultPaper.getWidth());
1683             hgt = ((hgt > 0.0) ? hgt : defaultPaper.getHeight());
1684             ix = ((ix > 0.0) ? ix : defaultPaper.getImageableX());
1685             iy = ((iy > 0.0) ? iy : defaultPaper.getImageableY());
1686             iw = ((iw > 0.0) ? iw : defaultPaper.getImageableWidth());
1687             ih = ((ih > 0.0) ? ih : defaultPaper.getImageableHeight());
1688             /* full width/height is not likely to be imageable, but since we
1689              * don't know the limits we have to allow it
1690              */
1691             if (iw > wid) {
1692                 iw = wid;
1693             }
1694             if (ih > hgt) {
1695                 ih = hgt;
1696             }
1697             if ((ix + iw) > wid) {
1698                 ix = wid - iw;
1699             }
1700             if ((iy + ih) > hgt) {
1701                 iy = hgt - ih;
1702             }
1703             newPaper.setSize(wid, hgt);
1704             newPaper.setImageableArea(ix, iy, iw, ih);
1705         }
1706     }
1707 
1708     /**
1709      * The passed in PageFormat will be copied and altered to describe
1710      * the default page size and orientation of the PrinterJob's
1711      * current printer.
1712      * Platform subclasses which can access the actual default paper size
1713      * for a printer may override this method.
1714      */
1715     public PageFormat defaultPage(PageFormat page) {
1716         PageFormat newPage = (PageFormat)page.clone();
1717         newPage.setOrientation(PageFormat.PORTRAIT);
1718         Paper newPaper = new Paper();
1719         double ptsPerInch = 72.0;
1720         double w, h;
1721         Media media = null;
1722 
1723         PrintService service = getPrintService();
1724         if (service != null) {
1725             MediaSize size;
1726             media =
1727                 (Media)service.getDefaultAttributeValue(Media.class);
1728 
1729             if (media instanceof MediaSizeName &&
1730                ((size = MediaSize.getMediaSizeForName((MediaSizeName)media)) !=
1731                 null)) {
1732                 w =  size.getX(MediaSize.INCH) * ptsPerInch;
1733                 h =  size.getY(MediaSize.INCH) * ptsPerInch;
1734                 newPaper.setSize(w, h);
1735                 newPaper.setImageableArea(ptsPerInch, ptsPerInch,
1736                                           w - 2.0*ptsPerInch,
1737                                           h - 2.0*ptsPerInch);
1738                 newPage.setPaper(newPaper);
1739                 return newPage;
1740 
1741             }
1742         }
1743 
1744         /* Default to A4 paper outside North America.
1745          */
1746         String defaultCountry = Locale.getDefault().getCountry();
1747         if (!Locale.getDefault().equals(Locale.ENGLISH) && // ie "C"
1748             defaultCountry != null &&
1749             !defaultCountry.equals(Locale.US.getCountry()) &&
1750             !defaultCountry.equals(Locale.CANADA.getCountry())) {
1751 
1752             double mmPerInch = 25.4;
1753             w = Math.rint((210.0*ptsPerInch)/mmPerInch);
1754             h = Math.rint((297.0*ptsPerInch)/mmPerInch);
1755             newPaper.setSize(w, h);
1756             newPaper.setImageableArea(ptsPerInch, ptsPerInch,
1757                                       w - 2.0*ptsPerInch,
1758                                       h - 2.0*ptsPerInch);
1759         }
1760 
1761         newPage.setPaper(newPaper);
1762 
1763         return newPage;
1764     }
1765 
1766     /**
1767      * The passed in PageFormat is cloned and altered to be usable on
1768      * the PrinterJob's current printer.
1769      */
1770     public PageFormat validatePage(PageFormat page) {
1771         PageFormat newPage = (PageFormat)page.clone();
1772         Paper newPaper = new Paper();
1773         validatePaper(newPage.getPaper(), newPaper);
1774         newPage.setPaper(newPaper);
1775 
1776         return newPage;
1777     }
1778 
1779     /**
1780      * Set the number of copies to be printed.
1781      */
1782     public void setCopies(int copies) {
1783         mNumCopies = copies;
1784     }
1785 
1786     /**
1787      * Get the number of copies to be printed.
1788      */
1789     public int getCopies() {
1790         return mNumCopies;
1791     }
1792 
1793    /* Used when executing a print job where an attribute set may
1794      * over ride API values.
1795      */
1796     protected int getCopiesInt() {
1797         return (copiesAttr > 0) ? copiesAttr : getCopies();
1798     }
1799 
1800     /**
1801      * Get the name of the printing user.
1802      * The caller must have security permission to read system properties.
1803      */
1804     public String getUserName() {
1805         return System.getProperty("user.name");
1806     }
1807 
1808    /* Used when executing a print job where an attribute set may
1809      * over ride API values.
1810      */
1811     protected String getUserNameInt() {
1812         if  (userNameAttr != null) {
1813             return userNameAttr;
1814         } else {
1815             try {
1816                 return  getUserName();
1817             } catch (SecurityException e) {
1818                 return "";
1819             }
1820         }
1821     }
1822 
1823     /**
1824      * Set the name of the document to be printed.
1825      * The document name can not be null.
1826      */
1827     public void setJobName(String jobName) {
1828         if (jobName != null) {
1829             mDocName = jobName;
1830         } else {
1831             throw new NullPointerException();
1832         }
1833     }
1834 
1835     /**
1836      * Get the name of the document to be printed.
1837      */
1838     public String getJobName() {
1839         return mDocName;
1840     }
1841 
1842     /* Used when executing a print job where an attribute set may
1843      * over ride API values.
1844      */
1845     protected String getJobNameInt() {
1846         return (jobNameAttr != null) ? jobNameAttr : getJobName();
1847     }
1848 
1849     /**
1850      * Set the range of pages from a Book to be printed.
1851      * Both 'firstPage' and 'lastPage' are zero based
1852      * page indices. If either parameter is less than
1853      * zero then the page range is set to be from the
1854      * first page to the last.
1855      */
1856     protected void setPageRange(int firstPage, int lastPage) {
1857         if(firstPage >= 0 && lastPage >= 0) {
1858             mFirstPage = firstPage;
1859             mLastPage = lastPage;
1860             if(mLastPage < mFirstPage) mLastPage = mFirstPage;
1861         } else {
1862             mFirstPage = Pageable.UNKNOWN_NUMBER_OF_PAGES;
1863             mLastPage = Pageable.UNKNOWN_NUMBER_OF_PAGES;
1864         }
1865     }
1866 
1867     /**
1868      * Return the zero based index of the first page to
1869      * be printed in this job.
1870      */
1871     protected int getFirstPage() {
1872         return mFirstPage == Book.UNKNOWN_NUMBER_OF_PAGES ? 0 : mFirstPage;
1873     }
1874 
1875     /**
1876      * Return the zero based index of the last page to
1877      * be printed in this job.
1878      */
1879     protected int getLastPage() {
1880         return mLastPage;
1881     }
1882 
1883     /**
1884      * Set whether copies should be collated or not.
1885      * Two collated copies of a three page document
1886      * print in this order: 1, 2, 3, 1, 2, 3 while
1887      * uncollated copies print in this order:
1888      * 1, 1, 2, 2, 3, 3.
1889      * This is set when request is using an attribute set.
1890      */
1891     protected void setCollated(boolean collate) {
1892         mCollate = collate;
1893         collateAttReq = true;
1894     }
1895 
1896     /**
1897      * Return true if collated copies will be printed as determined
1898      * in an attribute set.
1899      */
1900     protected boolean isCollated() {
1901             return mCollate;
1902     }
1903 
1904     protected final int getSelectAttrib() {
1905         if (attributes != null) {
1906             SunPageSelection pages =
1907                 (SunPageSelection)attributes.get(SunPageSelection.class);
1908             if (pages == SunPageSelection.RANGE) {
1909                 return PD_PAGENUMS;
1910             } else if (pages == SunPageSelection.SELECTION) {
1911                 return PD_SELECTION;
1912             } else if (pages ==  SunPageSelection.ALL) {
1913                 return PD_ALLPAGES;
1914             }
1915         }
1916         return PD_NOSELECTION;
1917     }
1918 
1919     //returns 1-based index for "From" page
1920     protected final int getFromPageAttrib() {
1921         if (attributes != null) {
1922             PageRanges pageRangesAttr =
1923                 (PageRanges)attributes.get(PageRanges.class);
1924             if (pageRangesAttr != null) {
1925                 int[][] range = pageRangesAttr.getMembers();
1926                 return range[0][0];
1927             }
1928         }
1929         return getMinPageAttrib();
1930     }
1931 
1932     //returns 1-based index for "To" page
1933     protected final int getToPageAttrib() {
1934         if (attributes != null) {
1935             PageRanges pageRangesAttr =
1936                 (PageRanges)attributes.get(PageRanges.class);
1937             if (pageRangesAttr != null) {
1938                 int[][] range = pageRangesAttr.getMembers();
1939                 return range[range.length-1][1];
1940             }
1941         }
1942         return getMaxPageAttrib();
1943     }
1944 
1945     protected final int getMinPageAttrib() {
1946         if (attributes != null) {
1947             SunMinMaxPage s =
1948                 (SunMinMaxPage)attributes.get(SunMinMaxPage.class);
1949             if (s != null) {
1950                 return s.getMin();
1951             }
1952         }
1953         return 1;
1954     }
1955 
1956     protected final int getMaxPageAttrib() {
1957         if (attributes != null) {
1958             SunMinMaxPage s =
1959                 (SunMinMaxPage)attributes.get(SunMinMaxPage.class);
1960             if (s != null) {
1961                 return s.getMax();
1962             }
1963         }
1964 
1965         Pageable pageable = getPageable();
1966         if (pageable != null) {
1967             int numPages = pageable.getNumberOfPages();
1968             if (numPages <= Pageable.UNKNOWN_NUMBER_OF_PAGES) {
1969                 numPages = MAX_UNKNOWN_PAGES;
1970             }
1971             return  ((numPages == 0) ? 1 : numPages);
1972         }
1973 
1974         return Integer.MAX_VALUE;
1975     }
1976     /**
1977      * Called by the print() method at the start of
1978      * a print job.
1979      */
1980     protected abstract void startDoc() throws PrinterException;
1981 
1982     /**
1983      * Called by the print() method at the end of
1984      * a print job.
1985      */
1986     protected abstract void endDoc() throws PrinterException;
1987 
1988     /* Called by cancelDoc */
1989     protected abstract void abortDoc();
1990 
1991 // MacOSX - made protected so subclasses can reference it.
1992     protected void cancelDoc() throws PrinterAbortException {
1993         abortDoc();
1994         synchronized (this) {
1995             userCancelled = false;
1996             performingPrinting = false;
1997             notify();
1998         }
1999         throw new PrinterAbortException();
2000     }
2001 
2002     /**
2003      * Returns how many times the entire book should
2004      * be printed by the PrintJob. If the printer
2005      * itself supports collation then this method
2006      * should return 1 indicating that the entire
2007      * book need only be printed once and the copies
2008      * will be collated and made in the printer.
2009      */
2010     protected int getCollatedCopies() {
2011         return isCollated() ? getCopiesInt() : 1;
2012     }
2013 
2014     /**
2015      * Returns how many times each page in the book
2016      * should be consecutively printed by PrintJob.
2017      * If the printer makes copies itself then this
2018      * method should return 1.
2019      */
2020     protected int getNoncollatedCopies() {
2021         return isCollated() ? 1 : getCopiesInt();
2022     }
2023 
2024 
2025     /* The printer graphics config is cached on the job, so that it can
2026      * be created once, and updated only as needed (for now only to change
2027      * the bounds if when using a Pageable the page sizes changes).
2028      */
2029 
2030     private int deviceWidth, deviceHeight;
2031     private AffineTransform defaultDeviceTransform;
2032     private PrinterGraphicsConfig pgConfig;
2033 
2034     synchronized void setGraphicsConfigInfo(AffineTransform at,
2035                                             double pw, double ph) {
2036         Point2D.Double pt = new Point2D.Double(pw, ph);
2037         at.transform(pt, pt);
2038 
2039         if (pgConfig == null ||
2040             defaultDeviceTransform == null ||
2041             !at.equals(defaultDeviceTransform) ||
2042             deviceWidth != (int)pt.getX() ||
2043             deviceHeight != (int)pt.getY()) {
2044 
2045                 deviceWidth = (int)pt.getX();
2046                 deviceHeight = (int)pt.getY();
2047                 defaultDeviceTransform = at;
2048                 pgConfig = null;
2049         }
2050     }
2051 
2052     synchronized PrinterGraphicsConfig getPrinterGraphicsConfig() {
2053         if (pgConfig != null) {
2054             return pgConfig;
2055         }
2056         String deviceID = "Printer Device";
2057         PrintService service = getPrintService();
2058         if (service != null) {
2059             deviceID = service.toString();
2060         }
2061         pgConfig = new PrinterGraphicsConfig(deviceID,
2062                                              defaultDeviceTransform,
2063                                              deviceWidth, deviceHeight);
2064         return pgConfig;
2065     }
2066 
2067     /**
2068      * Print a page from the provided document.
2069      * @return int Printable.PAGE_EXISTS if the page existed and was drawn and
2070      *             Printable.NO_SUCH_PAGE if the page did not exist.
2071      * @see java.awt.print.Printable
2072      */
2073     protected int printPage(Pageable document, int pageIndex)
2074         throws PrinterException
2075     {
2076         PageFormat page;
2077         PageFormat origPage;
2078         Printable painter;
2079         try {
2080             origPage = document.getPageFormat(pageIndex);
2081             page = (PageFormat)origPage.clone();
2082             painter = document.getPrintable(pageIndex);
2083         } catch (Exception e) {
2084             PrinterException pe =
2085                     new PrinterException("Error getting page or printable.[ " +
2086                                           e +" ]");
2087             pe.initCause(e);
2088             throw pe;
2089         }
2090 
2091         /* Get the imageable area from Paper instead of PageFormat
2092          * because we do not want it adjusted by the page orientation.
2093          */
2094         Paper paper = page.getPaper();
2095         // if non-portrait and 270 degree landscape rotation
2096         if (page.getOrientation() != PageFormat.PORTRAIT &&
2097             landscapeRotates270) {
2098 
2099             double left = paper.getImageableX();
2100             double top = paper.getImageableY();
2101             double width = paper.getImageableWidth();
2102             double height = paper.getImageableHeight();
2103             paper.setImageableArea(paper.getWidth()-left-width,
2104                                    paper.getHeight()-top-height,
2105                                    width, height);
2106             page.setPaper(paper);
2107             if (page.getOrientation() == PageFormat.LANDSCAPE) {
2108                 page.setOrientation(PageFormat.REVERSE_LANDSCAPE);
2109             } else {
2110                 page.setOrientation(PageFormat.LANDSCAPE);
2111             }
2112         }
2113 
2114         double xScale = getXRes() / 72.0;
2115         double yScale = getYRes() / 72.0;
2116 
2117         /* The deviceArea is the imageable area in the printer's
2118          * resolution.
2119          */
2120         Rectangle2D deviceArea =
2121             new Rectangle2D.Double(paper.getImageableX() * xScale,
2122                                    paper.getImageableY() * yScale,
2123                                    paper.getImageableWidth() * xScale,
2124                                    paper.getImageableHeight() * yScale);
2125 
2126         /* Build and hold on to a uniform transform so that
2127          * we can get back to device space at the beginning
2128          * of each band.
2129          */
2130         AffineTransform uniformTransform = new AffineTransform();
2131 
2132         /* The scale transform is used to switch from the
2133          * device space to the user's 72 dpi space.
2134          */
2135         AffineTransform scaleTransform = new AffineTransform();
2136         scaleTransform.scale(xScale, yScale);
2137 
2138         /* bandwidth is multiple of 4 as the data is used in a win32 DIB and
2139          * some drivers behave badly if scanlines aren't multiples of 4 bytes.
2140          */
2141         int bandWidth = (int) deviceArea.getWidth();
2142         if (bandWidth % 4 != 0) {
2143             bandWidth += (4 - (bandWidth % 4));
2144         }
2145         if (bandWidth <= 0) {
2146             throw new PrinterException("Paper's imageable width is too small.");
2147         }
2148 
2149         int deviceAreaHeight = (int)deviceArea.getHeight();
2150         if (deviceAreaHeight <= 0) {
2151             throw new PrinterException("Paper's imageable height is too small.");
2152         }
2153 
2154         /* Figure out the number of lines that will fit into
2155          * our maximum band size. The hard coded 3 reflects the
2156          * fact that we can only create 24 bit per pixel 3 byte BGR
2157          * BufferedImages. FIX.
2158          */
2159         int bandHeight = (MAX_BAND_SIZE / bandWidth / 3);
2160 
2161         int deviceLeft = (int)Math.rint(paper.getImageableX() * xScale);
2162         int deviceTop  = (int)Math.rint(paper.getImageableY() * yScale);
2163 
2164         /* The device transform is used to move the band down
2165          * the page using translates. Normally this is all it
2166          * would do, but since, when printing, the Window's
2167          * DIB format wants the last line to be first (lowest) in
2168          * memory, the deviceTransform moves the origin to the
2169          * bottom of the band and flips the origin. This way the
2170          * app prints upside down into the band which is the DIB
2171          * format.
2172          */
2173         AffineTransform deviceTransform = new AffineTransform();
2174         deviceTransform.translate(-deviceLeft, deviceTop);
2175         deviceTransform.translate(0, bandHeight);
2176         deviceTransform.scale(1, -1);
2177 
2178         /* Create a BufferedImage to hold the band. We set the clip
2179          * of the band to be tight around the bits so that the
2180          * application can use it to figure what part of the
2181          * page needs to be drawn. The clip is never altered in
2182          * this method, but we do translate the band's coordinate
2183          * system so that the app will see the clip moving down the
2184          * page though it s always around the same set of pixels.
2185          */
2186         BufferedImage pBand = new BufferedImage(1, 1,
2187                                                 BufferedImage.TYPE_3BYTE_BGR);
2188 
2189         /* Have the app draw into a PeekGraphics object so we can
2190          * learn something about the needs of the print job.
2191          */
2192 
2193         PeekGraphics peekGraphics = createPeekGraphics(pBand.createGraphics(),
2194                                                        this);
2195 
2196         Rectangle2D.Double pageFormatArea =
2197             new Rectangle2D.Double(page.getImageableX(),
2198                                    page.getImageableY(),
2199                                    page.getImageableWidth(),
2200                                    page.getImageableHeight());
2201         peekGraphics.transform(scaleTransform);
2202         peekGraphics.translate(-getPhysicalPrintableX(paper) / xScale,
2203                                -getPhysicalPrintableY(paper) / yScale);
2204         peekGraphics.transform(new AffineTransform(page.getMatrix()));
2205         initPrinterGraphics(peekGraphics, pageFormatArea);
2206         AffineTransform pgAt = peekGraphics.getTransform();
2207 
2208         /* Update the information used to return a GraphicsConfiguration
2209          * for this printer device. It needs to be updated per page as
2210          * not all pages in a job may be the same size (different bounds)
2211          * The transform is the scaling transform as this corresponds to
2212          * the default transform for the device. The width and height are
2213          * those of the paper, not the page format, as we want to describe
2214          * the bounds of the device in its natural coordinate system of
2215          * device coordinate whereas a page format may be in a rotated context.
2216          */
2217         setGraphicsConfigInfo(scaleTransform,
2218                               paper.getWidth(), paper.getHeight());
2219         int pageResult = painter.print(peekGraphics, origPage, pageIndex);
2220         debug_println("pageResult "+pageResult);
2221         if (pageResult == Printable.PAGE_EXISTS) {
2222             debug_println("startPage "+pageIndex);
2223 
2224             /* We need to check if the paper size is changed.
2225              * Note that it is not sufficient to ask for the pageformat
2226              * of "pageIndex-1", since PageRanges mean that pages can be
2227              * skipped. So we have to look at the actual last paper size used.
2228              */
2229             Paper thisPaper = page.getPaper();
2230             boolean paperChanged =
2231                 previousPaper == null ||
2232                 thisPaper.getWidth() != previousPaper.getWidth() ||
2233                 thisPaper.getHeight() != previousPaper.getHeight();
2234             previousPaper = thisPaper;
2235 
2236             startPage(page, painter, pageIndex, paperChanged);
2237             Graphics2D pathGraphics = createPathGraphics(peekGraphics, this,
2238                                                          painter, page,
2239                                                          pageIndex);
2240 
2241             /* If we can convert the page directly to the
2242              * underlying graphics system then we do not
2243              * need to rasterize. We also may not need to
2244              * create the 'band' if all the pages can take
2245              * this path.
2246              */
2247             if (pathGraphics != null) {
2248                 pathGraphics.transform(scaleTransform);
2249                 // user (0,0) should be origin of page, not imageable area
2250                 pathGraphics.translate(-getPhysicalPrintableX(paper) / xScale,
2251                                        -getPhysicalPrintableY(paper) / yScale);
2252                 pathGraphics.transform(new AffineTransform(page.getMatrix()));
2253                 initPrinterGraphics(pathGraphics, pageFormatArea);
2254 
2255                 redrawList.clear();
2256 
2257                 AffineTransform initialTx = pathGraphics.getTransform();
2258 
2259                 painter.print(pathGraphics, origPage, pageIndex);
2260 
2261                 for (int i=0;i<redrawList.size();i++) {
2262                    GraphicsState gstate = redrawList.get(i);
2263                    pathGraphics.setTransform(initialTx);
2264                    ((PathGraphics)pathGraphics).redrawRegion(
2265                                                          gstate.region,
2266                                                          gstate.sx,
2267                                                          gstate.sy,
2268                                                          gstate.theClip,
2269                                                          gstate.theTransform);
2270                 }
2271 
2272             /* This is the banded-raster printing loop.
2273              * It should be moved into its own method.
2274              */
2275             } else {
2276                 BufferedImage band = cachedBand;
2277                 if (cachedBand == null ||
2278                     bandWidth != cachedBandWidth ||
2279                     bandHeight != cachedBandHeight) {
2280                     band = new BufferedImage(bandWidth, bandHeight,
2281                                              BufferedImage.TYPE_3BYTE_BGR);
2282                     cachedBand = band;
2283                     cachedBandWidth = bandWidth;
2284                     cachedBandHeight = bandHeight;
2285                 }
2286                 Graphics2D bandGraphics = band.createGraphics();
2287 
2288                 Rectangle2D.Double clipArea =
2289                     new Rectangle2D.Double(0, 0, bandWidth, bandHeight);
2290 
2291                 initPrinterGraphics(bandGraphics, clipArea);
2292 
2293                 ProxyGraphics2D painterGraphics =
2294                     new ProxyGraphics2D(bandGraphics, this);
2295 
2296                 Graphics2D clearGraphics = band.createGraphics();
2297                 clearGraphics.setColor(Color.white);
2298 
2299                 /* We need the actual bits of the BufferedImage to send to
2300                  * the native Window's code. 'data' points to the actual
2301                  * pixels. Right now these are in ARGB format with 8 bits
2302                  * per component. We need to use a monochrome BufferedImage
2303                  * for monochrome printers when this is supported by
2304                  * BufferedImage. FIX
2305                  */
2306                 ByteInterleavedRaster tile = (ByteInterleavedRaster)band.getRaster();
2307                 byte[] data = tile.getDataStorage();
2308 
2309                 /* Loop over the page moving our band down the page,
2310                  * calling the app to render the band, and then send the band
2311                  * to the printer.
2312                  */
2313                 int deviceBottom = deviceTop + deviceAreaHeight;
2314 
2315                 /* device's printable x,y is really addressable origin
2316                  * we address relative to media origin so when we print a
2317                  * band we need to adjust for the different methods of
2318                  * addressing it.
2319                  */
2320                 int deviceAddressableX = (int)getPhysicalPrintableX(paper);
2321                 int deviceAddressableY = (int)getPhysicalPrintableY(paper);
2322 
2323                 for (int bandTop = 0; bandTop <= deviceAreaHeight;
2324                      bandTop += bandHeight)
2325                 {
2326 
2327                     /* Put the band back into device space and
2328                      * erase the contents of the band.
2329                      */
2330                     clearGraphics.fillRect(0, 0, bandWidth, bandHeight);
2331 
2332                     /* Put the band into the correct location on the
2333                      * page. Once the band is moved we translate the
2334                      * device transform so that the band will move down
2335                      * the page on the next iteration of the loop.
2336                      */
2337                     bandGraphics.setTransform(uniformTransform);
2338                     bandGraphics.transform(deviceTransform);
2339                     deviceTransform.translate(0, -bandHeight);
2340 
2341                     /* Switch the band from device space to user,
2342                      * 72 dpi, space.
2343                      */
2344                     bandGraphics.transform(scaleTransform);
2345                     bandGraphics.transform(new AffineTransform(page.getMatrix()));
2346 
2347                     Rectangle clip = bandGraphics.getClipBounds();
2348                     clip = pgAt.createTransformedShape(clip).getBounds();
2349 
2350                     if ((clip == null) || peekGraphics.hitsDrawingArea(clip) &&
2351                         (bandWidth > 0 && bandHeight > 0)) {
2352 
2353                         /* if the client has specified an imageable X or Y
2354                          * which is off than the physically addressable
2355                          * area of the page, then we need to adjust for that
2356                          * here so that we pass only non -ve band coordinates
2357                          * We also need to translate by the adjusted amount
2358                          * so that printing appears in the correct place.
2359                          */
2360                         int bandX = deviceLeft - deviceAddressableX;
2361                         if (bandX < 0) {
2362                             bandGraphics.translate(bandX/xScale,0);
2363                             bandX = 0;
2364                         }
2365                         int bandY = deviceTop + bandTop - deviceAddressableY;
2366                         if (bandY < 0) {
2367                             bandGraphics.translate(0,bandY/yScale);
2368                             bandY = 0;
2369                         }
2370                         /* Have the app's painter image into the band
2371                          * and then send the band to the printer.
2372                          */
2373                         painterGraphics.setDelegate((Graphics2D) bandGraphics.create());
2374                         painter.print(painterGraphics, origPage, pageIndex);
2375                         painterGraphics.dispose();
2376                         printBand(data, bandX, bandY, bandWidth, bandHeight);
2377                     }
2378                 }
2379 
2380                 clearGraphics.dispose();
2381                 bandGraphics.dispose();
2382 
2383             }
2384             debug_println("calling endPage "+pageIndex);
2385             endPage(page, painter, pageIndex);
2386         }
2387 
2388         return pageResult;
2389     }
2390 
2391     /**
2392      * If a print job is in progress, print() has been
2393      * called but has not returned, then this signals
2394      * that the job should be cancelled and the next
2395      * chance. If there is no print job in progress then
2396      * this call does nothing.
2397      */
2398     public void cancel() {
2399         synchronized (this) {
2400             if (performingPrinting) {
2401                 userCancelled = true;
2402             }
2403             notify();
2404         }
2405     }
2406 
2407     /**
2408      * Returns true is a print job is ongoing but will
2409      * be cancelled and the next opportunity. false is
2410      * returned otherwise.
2411      */
2412     public boolean isCancelled() {
2413 
2414         boolean cancelled = false;
2415 
2416         synchronized (this) {
2417             cancelled = (performingPrinting && userCancelled);
2418             notify();
2419         }
2420 
2421         return cancelled;
2422     }
2423 
2424     /**
2425      * Return the Pageable describing the pages to be printed.
2426      */
2427     protected Pageable getPageable() {
2428         return mDocument;
2429     }
2430 
2431     /**
2432      * Examine the metrics captured by the
2433      * {@code PeekGraphics} instance and
2434      * if capable of directly converting this
2435      * print job to the printer's control language
2436      * or the native OS's graphics primitives, then
2437      * return a {@code PathGraphics} to perform
2438      * that conversion. If there is not an object
2439      * capable of the conversion then return
2440      * {@code null}. Returning {@code null}
2441      * causes the print job to be rasterized.
2442      */
2443     protected Graphics2D createPathGraphics(PeekGraphics graphics,
2444                                             PrinterJob printerJob,
2445                                             Printable painter,
2446                                             PageFormat pageFormat,
2447                                             int pageIndex) {
2448 
2449         return null;
2450     }
2451 
2452     /**
2453      * Create and return an object that will
2454      * gather and hold metrics about the print
2455      * job. This method is passed a {@code Graphics2D}
2456      * object that can be used as a proxy for the
2457      * object gathering the print job matrics. The
2458      * method is also supplied with the instance
2459      * controlling the print job, {@code printerJob}.
2460      */
2461     protected PeekGraphics createPeekGraphics(Graphics2D graphics,
2462                                               PrinterJob printerJob) {
2463 
2464         return new PeekGraphics(graphics, printerJob);
2465     }
2466 
2467     /**
2468      * Configure the passed in Graphics2D so that
2469      * is contains the defined initial settings
2470      * for a print job. These settings are:
2471      *      color:  black.
2472      *      clip:   <as passed in>
2473      */
2474 // MacOSX - made protected so subclasses can reference it.
2475     protected void initPrinterGraphics(Graphics2D g, Rectangle2D clip) {
2476 
2477         g.setClip(clip);
2478         g.setPaint(Color.black);
2479     }
2480 
2481 
2482    /**
2483     * User dialogs should disable "File" buttons if this returns false.
2484     *
2485     */
2486     public boolean checkAllowedToPrintToFile() {
2487         try {
2488             throwPrintToFile();
2489             return true;
2490         } catch (SecurityException e) {
2491             return false;
2492         }
2493     }
2494 
2495     /**
2496      * Break this out as it may be useful when we allow API to
2497      * specify printing to a file. In that case its probably right
2498      * to throw a SecurityException if the permission is not granted
2499      */
2500     private void throwPrintToFile() {
2501         SecurityManager security = System.getSecurityManager();
2502         if (security != null) {
2503             if (printToFilePermission == null) {
2504                 printToFilePermission =
2505                     new FilePermission("<<ALL FILES>>", "read,write");
2506             }
2507             security.checkPermission(printToFilePermission);
2508         }
2509     }
2510 
2511     /* On-screen drawString renders most control chars as the missing glyph
2512      * and have the non-zero advance of that glyph.
2513      * Exceptions are \t, \n and \r which are considered zero-width.
2514      * This is a utility method used by subclasses to remove them so we
2515      * don't have to worry about platform or font specific handling of them.
2516      */
2517     protected String removeControlChars(String s) {
2518         char[] in_chars = s.toCharArray();
2519         int len = in_chars.length;
2520         char[] out_chars = new char[len];
2521         int pos = 0;
2522 
2523         for (int i = 0; i < len; i++) {
2524             char c = in_chars[i];
2525             if (c > '\r' || c < '\t' || c == '\u000b' || c == '\u000c')  {
2526                out_chars[pos++] = c;
2527             }
2528         }
2529         if (pos == len) {
2530             return s; // no need to make a new String.
2531         } else {
2532             return new String(out_chars, 0, pos);
2533         }
2534     }
2535 }
--- EOF ---