1 /*
   2  * Copyright (c) 2011, 2015, 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.lwawt.macosx;
  27 
  28 
  29 import java.awt.*;
  30 import java.awt.geom.Rectangle2D;
  31 import java.awt.image.BufferedImage;
  32 import java.awt.print.*;
  33 import java.security.AccessController;
  34 import java.security.PrivilegedAction;
  35 
  36 import javax.print.*;
  37 import javax.print.attribute.PrintRequestAttributeSet;
  38 import javax.print.attribute.HashPrintRequestAttributeSet;
  39 import javax.print.attribute.standard.Copies;
  40 import javax.print.attribute.standard.Media;
  41 import javax.print.attribute.standard.MediaPrintableArea;
  42 import javax.print.attribute.standard.MediaSize;
  43 import javax.print.attribute.standard.MediaSizeName;
  44 import javax.print.attribute.standard.PageRanges;
  45 
  46 import sun.java2d.*;
  47 import sun.misc.ManagedLocalsThread;
  48 import sun.print.*;
  49 
  50 public final class CPrinterJob extends RasterPrinterJob {
  51     // NOTE: This uses RasterPrinterJob as a base, but it doesn't use
  52     // all of the RasterPrinterJob functions. RasterPrinterJob will
  53     // break down printing to pieces that aren't necessary under MacOSX
  54     // printing, such as controlling the # of copies and collating. These
  55     // are handled by the native printing. RasterPrinterJob is kept for
  56     // future compatibility and the state keeping that it handles.
  57 
  58     private static String sShouldNotReachHere = "Should not reach here.";
  59 
  60     private volatile SecondaryLoop printingLoop;
  61 
  62     private boolean noDefaultPrinter = false;
  63 
  64     private static Font defaultFont;
  65 
  66     // This is the NSPrintInfo for this PrinterJob. Protect multi thread
  67     //  access to it. It is used by the pageDialog, jobDialog, and printLoop.
  68     //  This way the state of these items is shared across these calls.
  69     //  PageFormat data is passed in and set on the fNSPrintInfo on a per call
  70     //  basis.
  71     private long fNSPrintInfo = -1;
  72     private Object fNSPrintInfoLock = new Object();
  73 
  74     static {
  75         // AWT has to be initialized for the native code to function correctly.
  76         Toolkit.getDefaultToolkit();
  77     }
  78 
  79     /**
  80      * Presents a dialog to the user for changing the properties of
  81      * the print job.
  82      * This method will display a native dialog if a native print
  83      * service is selected, and user choice of printers will be restricted
  84      * to these native print services.
  85      * To present the cross platform print dialog for all services,
  86      * including native ones instead use
  87      * <code>printDialog(PrintRequestAttributeSet)</code>.
  88      * <p>
  89      * PrinterJob implementations which can use PrintService's will update
  90      * the PrintService for this PrinterJob to reflect the new service
  91      * selected by the user.
  92      * @return <code>true</code> if the user does not cancel the dialog;
  93      * <code>false</code> otherwise.
  94      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
  95      * returns true.
  96      * @see java.awt.GraphicsEnvironment#isHeadless
  97      */
  98     @Override
  99     public boolean printDialog() throws HeadlessException {
 100         if (GraphicsEnvironment.isHeadless()) {
 101             throw new HeadlessException();
 102         }
 103 
 104         if (noDefaultPrinter) {
 105             return false;
 106         }
 107 
 108         if (attributes == null) {
 109             attributes = new HashPrintRequestAttributeSet();
 110         }
 111 
 112         if (getPrintService() instanceof StreamPrintService) {
 113             return super.printDialog(attributes);
 114         }
 115 
 116         return jobSetup(getPageable(), checkAllowedToPrintToFile());
 117     }
 118 
 119     /**
 120      * Displays a dialog that allows modification of a
 121      * <code>PageFormat</code> instance.
 122      * The <code>page</code> argument is used to initialize controls
 123      * in the page setup dialog.
 124      * If the user cancels the dialog then this method returns the
 125      * original <code>page</code> object unmodified.
 126      * If the user okays the dialog then this method returns a new
 127      * <code>PageFormat</code> object with the indicated changes.
 128      * In either case, the original <code>page</code> object is
 129      * not modified.
 130      * @param page the default <code>PageFormat</code> presented to the
 131      *            user for modification
 132      * @return    the original <code>page</code> object if the dialog
 133      *            is cancelled; a new <code>PageFormat</code> object
 134      *          containing the format indicated by the user if the
 135      *          dialog is acknowledged.
 136      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 137      * returns true.
 138      * @see java.awt.GraphicsEnvironment#isHeadless
 139      * @since     1.2
 140      */
 141     @Override
 142     public PageFormat pageDialog(PageFormat page) throws HeadlessException {
 143         if (GraphicsEnvironment.isHeadless()) {
 144             throw new HeadlessException();
 145         }
 146 
 147         if (noDefaultPrinter) {
 148             return page;
 149         }
 150 
 151         if (getPrintService() instanceof StreamPrintService) {
 152             return super.pageDialog(page);
 153         }
 154 
 155         PageFormat pageClone = (PageFormat) page.clone();
 156         boolean doIt = pageSetup(pageClone, null);
 157         return doIt ? pageClone : page;
 158     }
 159 
 160     /**
 161      * Clones the <code>PageFormat</code> argument and alters the
 162      * clone to describe a default page size and orientation.
 163      * @param page the <code>PageFormat</code> to be cloned and altered
 164      * @return clone of <code>page</code>, altered to describe a default
 165      *                      <code>PageFormat</code>.
 166      */
 167     @Override
 168     public PageFormat defaultPage(PageFormat page) {
 169         PageFormat newPage = (PageFormat)page.clone();
 170         getDefaultPage(newPage);
 171         return newPage;
 172     }
 173 
 174     @Override
 175     protected void setAttributes(PrintRequestAttributeSet attributes) throws PrinterException {
 176         super.setAttributes(attributes);
 177 
 178         if (attributes == null) {
 179             return;
 180         }
 181 
 182         // See if this has an NSPrintInfo in it.
 183         NSPrintInfo nsPrintInfo = (NSPrintInfo)attributes.get(NSPrintInfo.class);
 184         if (nsPrintInfo != null) {
 185             fNSPrintInfo = nsPrintInfo.getValue();
 186         }
 187 
 188         PageRanges pageRangesAttr =  (PageRanges)attributes.get(PageRanges.class);
 189         if (isSupportedValue(pageRangesAttr, attributes)) {
 190             SunPageSelection rangeSelect = (SunPageSelection)attributes.get(SunPageSelection.class);
 191             // If rangeSelect is not null, we are using AWT's print dialog that has
 192             // All, Selection, and Range radio buttons
 193             if (rangeSelect == null || rangeSelect == SunPageSelection.RANGE) {
 194                 int[][] range = pageRangesAttr.getMembers();
 195                 // setPageRange will set firstPage and lastPage as called in getFirstPage
 196                 // and getLastPage
 197                 setPageRange(range[0][0] - 1, range[0][1] - 1);
 198             } else {
 199                 // if rangeSelect is SunPageSelection.ALL 
 200                 // then setPageRange appropriately
 201                 setPageRange(-1, -1);
 202             }
 203         }
 204     }
 205 
 206     private void setPageRangeAttribute(int from, int to, boolean isRangeSet) {
 207         if (attributes != null) {
 208             // since native Print use zero-based page indices,
 209             // we need to store in 1-based format in attributes set
 210             // but setPageRange again uses zero-based indices so it should be 
 211             // 1 less than pageRanges attribute
 212             if (isRangeSet) {
 213                 attributes.add(new PageRanges(from+1, to+1));
 214                 attributes.add(SunPageSelection.RANGE);        
 215                 setPageRange(from, to);
 216             } else {
 217                 attributes.add(SunPageSelection.ALL);
 218             }
 219   
 220         }
 221     }
 222     
 223     private void setCopiesAttribute(int copies) {
 224         if (attributes != null) {
 225             attributes.add(new Copies(copies));
 226             super.setCopies(copies);
 227         }
 228     }
 229     
 230     
 231     volatile boolean onEventThread;
 232 
 233     @Override
 234     protected void cancelDoc() throws PrinterAbortException {
 235         super.cancelDoc();
 236         if (printingLoop != null) {
 237             printingLoop.exit();
 238         }
 239     }
 240 
 241     private void completePrintLoop() {
 242         Runnable r = new Runnable() { public void run() {
 243             synchronized(this) {
 244                 performingPrinting = false;
 245             }
 246             if (printingLoop != null) {
 247                 printingLoop.exit();
 248             }
 249         }};
 250 
 251         if (onEventThread) {
 252             try { EventQueue.invokeAndWait(r); } catch (Exception e) { e.printStackTrace(); }
 253         } else {
 254             r.run();
 255         }
 256     }
 257 
 258     @Override
 259     public void print(PrintRequestAttributeSet attributes) throws PrinterException {
 260         // NOTE: Some of this code is copied from RasterPrinterJob.
 261 
 262 
 263         // this code uses javax.print APIs
 264         // this will make it print directly to the printer
 265         // this will not work if the user clicks on the "Preview" button
 266         // However if the printer is a StreamPrintService, its the right path.
 267         PrintService psvc = getPrintService();
 268         if (psvc instanceof StreamPrintService) {
 269             spoolToService(psvc, attributes);
 270             return;
 271         }
 272 
 273 
 274         setAttributes(attributes);
 275         // throw exception for invalid destination
 276         if (destinationAttr != null) {
 277             validateDestination(destinationAttr);
 278         }
 279 
 280         /* Get the range of pages we are to print. If the
 281          * last page to print is unknown, then we print to
 282          * the end of the document. Note that firstPage
 283          * and lastPage are 0 based page indices.
 284          */
 285 
 286         int firstPage = getFirstPage();
 287         int lastPage = getLastPage();
 288         if(lastPage == Pageable.UNKNOWN_NUMBER_OF_PAGES) {
 289             int totalPages = mDocument.getNumberOfPages();
 290             if (totalPages != Pageable.UNKNOWN_NUMBER_OF_PAGES) {
 291                 lastPage = mDocument.getNumberOfPages() - 1;
 292             }
 293         }
 294 
 295         try {
 296             synchronized (this) {
 297                 performingPrinting = true;
 298                 userCancelled = false;
 299             }
 300 
 301             //Add support for PageRange
 302             PageRanges pr = (attributes == null) ?  null
 303                                                  : (PageRanges)attributes.get(PageRanges.class);
 304             int[][] prMembers = (pr == null) ? new int[0][0] : pr.getMembers();
 305             int loopi = 0;
 306             do {
 307                 if (EventQueue.isDispatchThread()) {
 308                     // This is an AWT EventQueue, and this print rendering loop needs to block it.
 309 
 310                     onEventThread = true;
 311 
 312                     printingLoop = AccessController.doPrivileged(new PrivilegedAction<SecondaryLoop>() {
 313                         @Override
 314                         public SecondaryLoop run() {
 315                             return Toolkit.getDefaultToolkit()
 316                                     .getSystemEventQueue()
 317                                     .createSecondaryLoop();
 318                         }
 319                     });
 320 
 321                     try {
 322                         // Fire off the print rendering loop on the AppKit thread, and don't have
 323                         //  it wait and block this thread.
 324                         if (printLoop(false, firstPage, lastPage)) {
 325                             // Start a secondary loop on EDT until printing operation is finished or cancelled
 326                             printingLoop.enter();
 327                         }
 328                     } catch (Exception e) {
 329                         e.printStackTrace();
 330                     }
 331               } else {
 332                     // Fire off the print rendering loop on the AppKit, and block this thread
 333                     //  until it is done.
 334                     // But don't actually block... we need to come back here!
 335                     onEventThread = false;
 336 
 337                     try {
 338                         printLoop(true, firstPage, lastPage);
 339                     } catch (Exception e) {
 340                         e.printStackTrace();
 341                     }
 342                 }
 343                 if (++loopi < prMembers.length) {
 344                      firstPage = prMembers[loopi][0]-1;
 345                      lastPage = prMembers[loopi][1] -1;
 346                 }
 347             }  while (loopi < prMembers.length);
 348         } finally {
 349             synchronized (this) {
 350                 // NOTE: Native code shouldn't allow exceptions out while
 351                 // printing. They should cancel the print loop.
 352                 performingPrinting = false;
 353                 notify();
 354             }
 355             if (printingLoop != null) {
 356                 printingLoop.exit();
 357             }
 358         }
 359 
 360         // Normalize the collated, # copies, numPages, first/last pages. Need to
 361         //  make note of pageRangesAttr.
 362 
 363         // Set up NSPrintInfo with the java settings (PageFormat & Paper).
 364 
 365         // Create an NSView for printing. Have knowsPageRange return YES, and give the correct
 366         //  range, or MAX? if unknown. Have rectForPage do a peekGraphics check before returning
 367         //  the rectangle. Have drawRect do the real render of the page. Have printJobTitle do
 368         //  the right thing.
 369 
 370         // Call NSPrintOperation, it will call NSView.drawRect: for each page.
 371 
 372         // NSView.drawRect: will create a CPrinterGraphics with the current CGContextRef, and then
 373         //  pass this Graphics onto the Printable with the appropriate PageFormat and index.
 374 
 375         // Need to be able to cancel the NSPrintOperation (using code from RasterPrinterJob, be
 376         //  sure to initialize userCancelled and performingPrinting member variables).
 377 
 378         // Extensions available from AppKit: Print to PDF or EPS file!
 379     }
 380 
 381     /**
 382      * Returns the resolution in dots per inch across the width
 383      * of the page.
 384      */
 385     @Override
 386     protected double getXRes() {
 387         // NOTE: This is not used in the CPrinterJob code path.
 388         return 0;
 389     }
 390 
 391     /**
 392      * Returns the resolution in dots per inch down the height
 393      * of the page.
 394      */
 395     @Override
 396     protected double getYRes() {
 397         // NOTE: This is not used in the CPrinterJob code path.
 398         return 0;
 399     }
 400 
 401     /**
 402      * Must be obtained from the current printer.
 403      * Value is in device pixels.
 404      * Not adjusted for orientation of the paper.
 405      */
 406     @Override
 407     protected double getPhysicalPrintableX(Paper p) {
 408         // NOTE: This is not used in the CPrinterJob code path.
 409         return 0;
 410     }
 411 
 412     /**
 413      * Must be obtained from the current printer.
 414      * Value is in device pixels.
 415      * Not adjusted for orientation of the paper.
 416      */
 417     @Override
 418     protected double getPhysicalPrintableY(Paper p) {
 419         // NOTE: This is not used in the CPrinterJob code path.
 420         return 0;
 421     }
 422 
 423     /**
 424      * Must be obtained from the current printer.
 425      * Value is in device pixels.
 426      * Not adjusted for orientation of the paper.
 427      */
 428     @Override
 429     protected double getPhysicalPrintableWidth(Paper p) {
 430         // NOTE: This is not used in the CPrinterJob code path.
 431         return 0;
 432     }
 433 
 434     /**
 435      * Must be obtained from the current printer.
 436      * Value is in device pixels.
 437      * Not adjusted for orientation of the paper.
 438      */
 439     @Override
 440     protected double getPhysicalPrintableHeight(Paper p) {
 441         // NOTE: This is not used in the CPrinterJob code path.
 442         return 0;
 443     }
 444 
 445     /**
 446      * Must be obtained from the current printer.
 447      * Value is in device pixels.
 448      * Not adjusted for orientation of the paper.
 449      */
 450     @Override
 451     protected double getPhysicalPageWidth(Paper p) {
 452         // NOTE: This is not used in the CPrinterJob code path.
 453         return 0;
 454     }
 455 
 456     /**
 457      * Must be obtained from the current printer.
 458      * Value is in device pixels.
 459      * Not adjusted for orientation of the paper.
 460      */
 461     @Override
 462     protected double getPhysicalPageHeight(Paper p) {
 463         // NOTE: This is not used in the CPrinterJob code path.
 464         return 0;
 465     }
 466 
 467     /**
 468      * Begin a new page. This call's Window's
 469      * StartPage routine.
 470      */
 471     protected void startPage(PageFormat format, Printable painter, int index) throws PrinterException {
 472         // NOTE: This is not used in the CPrinterJob code path.
 473         throw new PrinterException(sShouldNotReachHere);
 474     }
 475 
 476     /**
 477      * End a page.
 478      */
 479     @Override
 480     protected void endPage(PageFormat format, Printable painter, int index) throws PrinterException {
 481         // NOTE: This is not used in the CPrinterJob code path.
 482         throw new PrinterException(sShouldNotReachHere);
 483     }
 484 
 485     /**
 486      * Prints the contents of the array of ints, 'data'
 487      * to the current page. The band is placed at the
 488      * location (x, y) in device coordinates on the
 489      * page. The width and height of the band is
 490      * specified by the caller.
 491      */
 492     @Override
 493     protected void printBand(byte[] data, int x, int y, int width, int height) throws PrinterException {
 494         // NOTE: This is not used in the CPrinterJob code path.
 495         throw new PrinterException(sShouldNotReachHere);
 496     }
 497 
 498     /**
 499      * Called by the print() method at the start of
 500      * a print job.
 501      */
 502     @Override
 503     protected void startDoc() throws PrinterException {
 504         // NOTE: This is not used in the CPrinterJob code path.
 505         throw new PrinterException(sShouldNotReachHere);
 506     }
 507 
 508     /**
 509      * Called by the print() method at the end of
 510      * a print job.
 511      */
 512     @Override
 513     protected void endDoc() throws PrinterException {
 514         // NOTE: This is not used in the CPrinterJob code path.
 515         throw new PrinterException(sShouldNotReachHere);
 516     }
 517 
 518     /* Called by cancelDoc */
 519     @Override
 520     protected native void abortDoc();
 521 
 522     /**
 523      * Displays the page setup dialog placing the user's
 524      * settings into 'page'.
 525      */
 526     public boolean pageSetup(PageFormat page, Printable painter) {
 527         CPrinterDialog printerDialog = new CPrinterPageDialog(null, this, page, painter);
 528         printerDialog.setVisible(true);
 529         boolean result = printerDialog.getRetVal();
 530         printerDialog.dispose();
 531         return result;
 532     }
 533 
 534     /**
 535      * Displays the print dialog and records the user's settings
 536      * into this object. Return false if the user cancels the
 537      * dialog.
 538      * If the dialog is to use a set of attributes, useAttributes is true.
 539      */
 540     private boolean jobSetup(Pageable doc, boolean allowPrintToFile) {
 541         CPrinterDialog printerDialog = new CPrinterJobDialog(null, this, doc, allowPrintToFile);
 542         printerDialog.setVisible(true);
 543         boolean result = printerDialog.getRetVal();
 544         printerDialog.dispose();
 545         return result;
 546     }
 547 
 548     /**
 549      * Alters the orientation and Paper to match defaults obtained
 550      * from a printer.
 551      */
 552     private native void getDefaultPage(PageFormat page);
 553 
 554     /**
 555      * validate the paper size against the current printer.
 556      */
 557     @Override
 558     protected native void validatePaper(Paper origPaper, Paper newPaper );
 559 
 560     // The following methods are CPrinterJob specific.
 561 
 562     @Override
 563     protected void finalize() {
 564         if (fNSPrintInfo != -1) {
 565             dispose(fNSPrintInfo);
 566         }
 567     }
 568 
 569     private native long createNSPrintInfo();
 570     private native void dispose(long printInfo);
 571 
 572     private long getNSPrintInfo() {
 573         // This is called from the native side.
 574         synchronized (fNSPrintInfoLock) {
 575             if (fNSPrintInfo == -1) {
 576                 fNSPrintInfo = createNSPrintInfo();
 577             }
 578             return fNSPrintInfo;
 579         }
 580     }
 581 
 582     private native boolean printLoop(boolean waitUntilDone, int firstPage, int lastPage) throws PrinterException;
 583 
 584     private PageFormat getPageFormat(int pageIndex) {
 585         // This is called from the native side.
 586         PageFormat page;
 587         try {
 588             page = getPageable().getPageFormat(pageIndex);
 589         } catch (Exception e) {
 590             return null;
 591         }
 592         return page;
 593     }
 594 
 595     private Printable getPrintable(int pageIndex) {
 596         // This is called from the native side.
 597         Printable painter;
 598         try {
 599             painter = getPageable().getPrintable(pageIndex);
 600         } catch (Exception e) {
 601             return null;
 602         }
 603         return painter;
 604     }
 605 
 606     private String getPrinterName(){
 607         // This is called from the native side.
 608         PrintService service = getPrintService();
 609         if (service == null) return null;
 610         return service.getName();
 611     }
 612 
 613     private void setPrinterServiceFromNative(String printerName) {
 614         // This is called from the native side.
 615         PrintService[] services = PrintServiceLookup.lookupPrintServices(DocFlavor.SERVICE_FORMATTED.PAGEABLE, null);
 616 
 617         for (int i = 0; i < services.length; i++) {
 618             PrintService service = services[i];
 619 
 620             if (printerName.equals(service.getName())) {
 621                 try {
 622                     setPrintService(service);
 623                 } catch (PrinterException e) {
 624                     // ignored
 625                 }
 626                 return;
 627             }
 628         }
 629     }
 630 
 631     private Rectangle2D getPageFormatArea(PageFormat page) {
 632         Rectangle2D.Double pageFormatArea =
 633             new Rectangle2D.Double(page.getImageableX(),
 634                     page.getImageableY(),
 635                     page.getImageableWidth(),
 636                     page.getImageableHeight());
 637         return pageFormatArea;
 638     }
 639       
 640     private boolean cancelCheck() {
 641         // This is called from the native side.
 642 
 643         // This is used to avoid deadlock
 644         // We would like to just call if isCancelled(),
 645         // but that will block the AppKit thread against whomever is holding the synchronized lock
 646         boolean cancelled = (performingPrinting && userCancelled);
 647         if (cancelled) {
 648             try {
 649                 LWCToolkit.invokeLater(new Runnable() { public void run() {
 650                     try {
 651                     cancelDoc();
 652                     } catch (PrinterAbortException pae) {
 653                         // no-op, let the native side handle it
 654                     }
 655                 }}, null);
 656             } catch (java.lang.reflect.InvocationTargetException ite) {}
 657         }
 658         return cancelled;
 659     }
 660 
 661     private PeekGraphics createFirstPassGraphics(PrinterJob printerJob, PageFormat page) {
 662         // This is called from the native side.
 663         BufferedImage bimg = new BufferedImage((int)Math.round(page.getWidth()), (int)Math.round(page.getHeight()), BufferedImage.TYPE_INT_ARGB_PRE);
 664         PeekGraphics peekGraphics = createPeekGraphics(bimg.createGraphics(), printerJob);
 665         Rectangle2D pageFormatArea = getPageFormatArea(page);
 666         initPrinterGraphics(peekGraphics, pageFormatArea);
 667         return peekGraphics;
 668     }
 669 
 670     private void printToPathGraphics(    final PeekGraphics graphics, // Always an actual PeekGraphics
 671                                         final PrinterJob printerJob, // Always an actual CPrinterJob
 672                                         final Printable painter, // Client class
 673                                         final PageFormat page, // Client class
 674                                         final int pageIndex,
 675                                         final long context) throws PrinterException {
 676         // This is called from the native side.
 677         Runnable r = new Runnable() { public void run() {
 678             try {
 679                 SurfaceData sd = CPrinterSurfaceData.createData(page, context); // Just stores page into an ivar
 680                 if (defaultFont == null) {
 681                     defaultFont = new Font("Dialog", Font.PLAIN, 12);
 682                 }
 683                 Graphics2D delegate = new SunGraphics2D(sd, Color.black, Color.white, defaultFont);
 684 
 685                 Graphics2D pathGraphics = new CPrinterGraphics(delegate, printerJob); // Just stores delegate into an ivar
 686                 Rectangle2D pageFormatArea = getPageFormatArea(page);    
 687                 initPrinterGraphics(pathGraphics, pageFormatArea);
 688                 painter.print(pathGraphics, page, pageIndex);
 689                 delegate.dispose();
 690                 delegate = null;
 691         } catch (PrinterException pe) { throw new java.lang.reflect.UndeclaredThrowableException(pe); }
 692         }};
 693 
 694         if (onEventThread) {
 695             try { EventQueue.invokeAndWait(r);
 696             } catch (java.lang.reflect.InvocationTargetException ite) {
 697                 Throwable te = ite.getTargetException();
 698                 if (te instanceof PrinterException) throw (PrinterException)te;
 699                 else te.printStackTrace();
 700             } catch (Exception e) { e.printStackTrace(); }
 701         } else {
 702             r.run();
 703         }
 704 
 705     }
 706 
 707     // Returns either 1. an array of 3 object (PageFormat, Printable, PeekGraphics) or 2. null
 708     private Object[] getPageformatPrintablePeekgraphics(final int pageIndex) {
 709         final Object[] ret = new Object[3];
 710         final PrinterJob printerJob = this;
 711 
 712         Runnable r = new Runnable() { public void run() { synchronized(ret) {
 713             try {
 714                 Pageable pageable = getPageable();
 715                 PageFormat pageFormat = pageable.getPageFormat(pageIndex);
 716                 if (pageFormat != null) {
 717                     Printable printable = pageable.getPrintable(pageIndex);
 718                     if (printable != null) {
 719                         BufferedImage bimg = new BufferedImage((int)Math.round(pageFormat.getWidth()), (int)Math.round(pageFormat.getHeight()), BufferedImage.TYPE_INT_ARGB_PRE);
 720                         PeekGraphics peekGraphics = createPeekGraphics(bimg.createGraphics(), printerJob);
 721                         Rectangle2D pageFormatArea = getPageFormatArea(pageFormat);                                               
 722                         initPrinterGraphics(peekGraphics, pageFormatArea);
 723 
 724                         // Do the assignment here!
 725                         ret[0] = pageFormat;
 726                         ret[1] = printable;
 727                         ret[2] = peekGraphics;
 728                     }
 729                 }
 730             } catch (Exception e) {} // Original code bailed on any exception
 731         }}};
 732 
 733         if (onEventThread) {
 734             try { EventQueue.invokeAndWait(r); } catch (Exception e) { e.printStackTrace(); }
 735         } else {
 736             r.run();
 737         }
 738 
 739         synchronized(ret) {
 740             if (ret[2] != null)
 741                 return ret;
 742             return null;
 743         }
 744     }
 745 
 746     private Rectangle2D printAndGetPageFormatArea(final Printable printable, final Graphics graphics, final PageFormat pageFormat, final int pageIndex) {
 747         final Rectangle2D[] ret = new Rectangle2D[1];
 748 
 749         Runnable r = new Runnable() { public void run() { synchronized(ret) {
 750             try {
 751                 int pageResult = printable.print(graphics, pageFormat, pageIndex);
 752                 if (pageResult != Printable.NO_SUCH_PAGE) {
 753                     ret[0] = getPageFormatArea(pageFormat);
 754                 }
 755             } catch (Exception e) {} // Original code bailed on any exception
 756         }}};
 757 
 758         if (onEventThread) {
 759             try { EventQueue.invokeAndWait(r); } catch (Exception e) { e.printStackTrace(); }
 760         } else {
 761             r.run();
 762         }
 763 
 764         synchronized(ret) { return ret[0]; }
 765     }
 766 
 767     // upcall from native
 768     private static void detachPrintLoop(final long target, final long arg) {
 769         new ManagedLocalsThread(() -> _safePrintLoop(target, arg)).start();
 770     }
 771     private static native void _safePrintLoop(long target, long arg);
 772 
 773     @Override
 774     protected void startPage(PageFormat arg0, Printable arg1, int arg2, boolean arg3) throws PrinterException {
 775         // TODO Auto-generated method stub
 776     }
 777 
 778     @Override
 779     protected MediaSize getMediaSize(Media media, PrintService service,
 780             PageFormat page) {
 781         if (media == null || !(media instanceof MediaSizeName)) {
 782             return getDefaultMediaSize(page);
 783         }
 784         MediaSize size = MediaSize.getMediaSizeForName((MediaSizeName) media);
 785         return size != null ? size : getDefaultMediaSize(page);
 786     }
 787 
 788     private MediaSize getDefaultMediaSize(PageFormat page){
 789             final int inch = 72;
 790             Paper paper = page.getPaper();
 791             float width = (float) (paper.getWidth() / inch);
 792             float height = (float) (paper.getHeight() / inch);
 793             return new MediaSize(width, height, MediaSize.INCH);
 794     }
 795 
 796     @Override
 797     protected MediaPrintableArea getDefaultPrintableArea(PageFormat page, double w, double h) {
 798         final float dpi = 72.0f;
 799         Paper paper = page.getPaper();
 800         return new MediaPrintableArea(
 801                 (float) (paper.getImageableX() / dpi),
 802                 (float) (paper.getImageableY() / dpi),
 803                 (float) (paper.getImageableWidth() / dpi),
 804                 (float) (paper.getImageableHeight() / dpi),
 805                 MediaPrintableArea.INCH);
 806     }
 807 }
--- EOF ---