/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.awt.windows;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.GraphicsEnvironment;

import java.awt.HeadlessException;

import java.awt.KeyboardFocusManager;

import java.awt.Toolkit;

import java.awt.BasicStroke;

import java.awt.Button;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.Event;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.FileDialog;

import java.awt.Dialog;

import java.awt.Label;

import java.awt.Panel;

import java.awt.Rectangle;

import java.awt.Window;

import java.awt.image.BufferedImage;

import java.awt.image.IndexColorModel;

import java.awt.print.Pageable;

import java.awt.print.PageFormat;

import java.awt.print.Paper;

import java.awt.print.Printable;

import java.awt.print.PrinterJob;

import java.awt.print.PrinterException;

import javax.print.PrintService;

import java.io.IOException;

import java.io.File;

import java.util.Hashtable;

import java.util.Properties;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import sun.awt.Win32GraphicsEnvironment;

import sun.print.PeekGraphics;

import sun.print.PeekMetrics;

import java.net.URL;

import java.net.URI;

import java.net.URISyntaxException;

import javax.print.PrintServiceLookup;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.HashPrintServiceAttributeSet;

import javax.print.attribute.HashPrintRequestAttributeSet;

import javax.print.attribute.Attribute;

import javax.print.attribute.standard.Sides;

import javax.print.attribute.standard.Chromaticity;

import javax.print.attribute.standard.PrintQuality;

import javax.print.attribute.standard.PrinterResolution;

import javax.print.attribute.standard.SheetCollate;

import javax.print.attribute.IntegerSyntax;

import javax.print.attribute.standard.Copies;

import javax.print.attribute.standard.Destination;

import javax.print.attribute.standard.OrientationRequested;

import javax.print.attribute.standard.Media;

import javax.print.attribute.standard.MediaSizeName;

import javax.print.attribute.standard.MediaSize;

import javax.print.attribute.standard.MediaTray;

import javax.print.attribute.standard.PrinterName;

import javax.print.attribute.standard.JobMediaSheetsSupported;

import javax.print.attribute.standard.PageRanges;

import javax.print.attribute.Size2DSyntax;

import javax.print.StreamPrintService;

import sun.awt.Win32FontManager;

import sun.print.RasterPrinterJob;

import sun.print.SunAlternateMedia;

import sun.print.SunPageSelection;

import sun.print.SunMinMaxPage;

import sun.print.Win32MediaTray;

import sun.print.Win32PrintService;

import sun.print.Win32PrintServiceLookup;

import sun.print.ServiceDialog;

import sun.print.DialogOwner;

import java.awt.Frame;

import java.io.FilePermission;

import sun.java2d.Disposer;

import sun.java2d.DisposerRecord;

import sun.java2d.DisposerTarget;

/**

 * A class which initiates and executes a Win32 printer job.

 *

 * @author Richard Blanchard

 */

public class WPrinterJob extends RasterPrinterJob implements DisposerTarget {

 /* Class Constants */

/* Instance Variables */

    /**

     * These are Windows' ExtCreatePen End Cap Styles

     * and must match the values in <WINGDI.h>

     */

    protected static final long PS_ENDCAP_ROUND  = 0x00000000;

    protected static final long PS_ENDCAP_SQUARE   = 0x00000100;

    protected static final long PS_ENDCAP_FLAT   =   0x00000200;

    /**

     * These are Windows' ExtCreatePen Line Join Styles

     * and must match the values in <WINGDI.h>

     */

    protected static final long PS_JOIN_ROUND   =    0x00000000;

    protected static final long PS_JOIN_BEVEL   =    0x00001000;

    protected static final long PS_JOIN_MITER   =    0x00002000;

    /**

     * This is the Window's Polygon fill rule which

     * Selects alternate mode (fills the area between odd-numbered

     * and even-numbered polygon sides on each scan line).

     * It must match the value in <WINGDI.h> It can be passed

     * to setPolyFillMode().

     */

    protected static final int POLYFILL_ALTERNATE = 1;

    /**

     * This is the Window's Polygon fill rule which

     * Selects winding mode which fills any region

     * with a nonzero winding value). It must match

     * the value in <WINGDI.h> It can be passed

     * to setPolyFillMode().

     */

    protected static final int POLYFILL_WINDING = 2;

    /**

     * The maximum value for a Window's color component

     * as passed to selectSolidBrush.

     */

    private static final int MAX_WCOLOR = 255;

    /**

     * Flags for setting values from devmode in native code.

     * Values must match those defined in awt_PrintControl.cpp

     */

    private static final int SET_DUP_VERTICAL = 0x00000010;

    private static final int SET_DUP_HORIZONTAL = 0x00000020;

    private static final int SET_RES_HIGH = 0x00000040;

    private static final int SET_RES_LOW = 0x00000080;

    private static final int SET_COLOR = 0x00000200;

    private static final int SET_ORIENTATION = 0x00004000;

    /**

     * Values must match those defined in wingdi.h & commdlg.h

     */

    private static final int PD_ALLPAGES = 0x00000000;

    private static final int PD_SELECTION = 0x00000001;

    private static final int PD_PAGENUMS = 0x00000002;

    private static final int PD_NOSELECTION = 0x00000004;

    private static final int PD_COLLATE = 0x00000010;

    private static final int PD_PRINTTOFILE = 0x00000020;

    private static final int DM_ORIENTATION = 0x00000001;

    private static final int DM_PRINTQUALITY = 0x00000400;

    private static final int DM_COLOR = 0x00000800;

    private static final int DM_DUPLEX = 0x00001000;

    /**

     * Pageable MAX pages

     */

    private static final int MAX_UNKNOWN_PAGES = 9999;

    /* Collation and copy flags.

     * The Windows PRINTDLG struct has a nCopies field which on return

     * indicates how many copies of a print job an application must render.

     * There is also a PD_COLLATE member of the flags field which if

     * set on return indicates the application generated copies should be

     * collated.

     * Windows printer drivers typically - but not always - support

     * generating multiple copies themselves, but uncollated is more

     * universal than collated copies.

     * When they do, they read the initial values from the PRINTDLG structure

     * and set them into the driver's DEVMODE structure and intialise

     * the printer DC based on that, so that when printed those settings

     * will be used.

     * For drivers supporting both these capabilities via DEVMODE, then on

     * return from the Print Dialog, nCopies is set to 1 and the PD_COLLATE is

     * cleared, so that the application will only render 1 copy and the

     * driver takes care of the rest.

     *

     * Applications which want to know what's going on have to be DEVMODE

     * savvy and peek at that.

     * DM_COPIES flag indicates support for multiple driver copies

     * and dmCopies is the number of copies the driver will print

     * DM_COLLATE flag indicates support for collated driver copies and

     * dmCollate == DMCOLLATE_TRUE indicates the option is in effect.

     *

     * Multiple copies from Java applications:

     * We provide API to get & set the number of copies as well as allowing the

     * user to choose it, so we need to be savvy about DEVMODE, so that

     * we can accurately report back the number of copies selected by

     * the user, as well as make use of the driver to render multiple copies.

     *

     * Collation and Java applications:

     * We presently provide no API for specifying collation, but its

     * present on the Windows Print Dialog, and when a user checks it

     * they expect it to be obeyed.

     * The best thing to do is to detect exactly the cases where the

     * driver doesn't support this and render multiple copies ourselves.

     * To support all this we need several flags which signal the

     * printer's capabilities and the user's requests.

     * Its questionable if we (yet) need to make a distinction between

     * the user requesting collation and the driver supporting it.

     * Since for now we only need to know whether we need to render the

     * copies. However it allows the logic to be clearer.

     * These fields are changed by native code which detects the driver's

     * capabilities and the user's choices.

     */

    //initialize to false because the Flags that we initialized in PRINTDLG

    // tells GDI that we can handle our own collation and multiple copies

     private boolean driverDoesMultipleCopies = false;

     private boolean driverDoesCollation = false;

     private boolean userRequestedCollation = false;

     private boolean noDefaultPrinter = false;

    /* The HandleRecord holds the native resources that need to be freed

     * when this WPrinterJob is GC'd.

     */

    static class HandleRecord implements DisposerRecord {

        /**

         * The Windows device context we will print into.

         * This variable is set after the Print dialog

         * is okayed by the user. If the user cancels

         * the print dialog, then this variable is 0.

         * Much of the configuration information for a printer is

         * obtained through printer device specific handles.

         * We need to associate these with, and free with, the mPrintDC.

         */

        private long mPrintDC;

        private long mPrintHDevMode;

        private long mPrintHDevNames;

        public void dispose() {

            WPrinterJob.deleteDC(mPrintDC, mPrintHDevMode, mPrintHDevNames);

        }

    }

    private HandleRecord handleRecord = new HandleRecord();

    private int mPrintPaperSize;

    /* These fields are directly set in upcalls from the values

     * obtained from calling DeviceCapabilities()

     */

    private int mPrintXRes;   // pixels per inch in x direction

    private int mPrintYRes;   // pixels per inch in y direction

    private int mPrintPhysX;  // x offset in pixels of printable area

    private int mPrintPhysY;  // y offset in pixels of printable area

    private int mPrintWidth;  // width in pixels of printable area

    private int mPrintHeight; // height in pixels of printable area

    private int mPageWidth;   // width in pixels of entire page

    private int mPageHeight;  // height in pixels of entire page

    /* The values of the following variables are pulled directly

     * into native code (even bypassing getter methods) when starting a doc.

     * So these need to be synced up from any resulting native changes

     * by a user dialog.

     * But the native changes call up to into the attributeset, and that

     * should be sufficient, since before heading down to native either

     * to (re-)display a dialog, or to print the doc, these are all

     * re-populated from the AttributeSet,

     * Nonetheless having them in sync with the attributeset and native

     * state is probably safer.

     * Also whereas the startDoc native code pulls the variables directly,

     * the dialog code does use getter to pull some of these values.

     * That's an inconsistency we should fix if it causes problems.

     */

    private int mAttSides;

    private int mAttChromaticity;

    private int mAttXRes;

    private int mAttYRes;

    private int mAttQuality;

    private int mAttCollate;

    private int mAttCopies;

    private int mAttMediaSizeName;

    private int mAttMediaTray;

    private String mDestination = null;

    /**

     * The last color set into the print device context or

     * <code>null</code> if no color has been set.

     */

    private Color mLastColor;

    /**

     * The last text color set into the print device context or

     * <code>null</code> if no color has been set.

     */

    private Color mLastTextColor;

    /**

     * Define the most recent java font set as a GDI font in the printer

     * device context. mLastFontFamily will be NULL if no

     * GDI font has been set.

     */

    private String mLastFontFamily;

    private float mLastFontSize;

    private int mLastFontStyle;

    private int mLastRotation;

    private float mLastAwScale;

    // for AwtPrintControl::InitPrintDialog

    private PrinterJob pjob;

    private java.awt.peer.ComponentPeer dialogOwnerPeer = null;

 /* Static Initializations */

    static {

        // AWT has to be initialized for the native code to function correctly.

        Toolkit.getDefaultToolkit();

        initIDs();

        Win32FontManager.registerJREFontsForPrinting();

    }

    /* Constructors */

    public WPrinterJob()

    {

        Disposer.addRecord(disposerReferent,

                           handleRecord = new HandleRecord());

        initAttributeMembers();

    }

    /* Implement DisposerTarget. Weak references to an Object can delay

     * its storage reclaimation marginally.

     * It won't make the native resources be release any more quickly, but

     * by pointing the reference held by Disposer at an object which becomes

     * no longer strongly reachable when this WPrinterJob is no longer

     * strongly reachable, we allow the WPrinterJob to be freed more promptly

     * than if it were the referenced object.

     */

    private Object disposerReferent = new Object();

    public Object getDisposerReferent() {

        return disposerReferent;

    }

/* Instance Methods */

    /**

     * Display a dialog to the user allowing the modification of a

     * PageFormat instance.

     * The <code>page</code> argument is used to initialize controls

     * in the page setup dialog.

     * If the user cancels the dialog, then the method returns the

     * original <code>page</code> object unmodified.

     * If the user okays the dialog then the method returns a new

     * PageFormat object with the indicated changes.

     * In either case the original <code>page</code> object will

     * not be modified.

     * @param     page    the default PageFormat presented to the user

     *                    for modification

     * @return    the original <code>page</code> object if the dialog

     *            is cancelled, or a new PageFormat object containing

     *            the format indicated by the user if the dialog is

     *            acknowledged

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     * returns true.

     * @see java.awt.GraphicsEnvironment#isHeadless

     * @since     JDK1.2

     */

    public PageFormat pageDialog(PageFormat page) throws HeadlessException {

        if (GraphicsEnvironment.isHeadless()) {

            throw new HeadlessException();

        }

        if (getPrintService() instanceof StreamPrintService) {

            return super.pageDialog(page);

        }

        PageFormat pageClone = (PageFormat) page.clone();

        boolean result = false;

        /*

         * Fix for 4507585: show the native modal dialog the same way printDialog() does so

         * that it won't block event dispatching when called on EventDispatchThread.

         */

        WPageDialog dialog = new WPageDialog((Frame)null, this,

                                     pageClone, null);

        dialog.setRetVal(false);

        dialog.setVisible(true);

        result = dialog.getRetVal();

        dialog.dispose();

        // myService => current PrintService

        if (result && (myService != null)) {

            // It's possible that current printer is changed through

            // the "Printer..." button so we query again from native.

            String printerName = getNativePrintService();

            if (!myService.getName().equals(printerName)) {

                // native printer is different !

                // we update the current PrintService

                try {

                    setPrintService(Win32PrintServiceLookup.

                                    getWin32PrintLUS().

                                    getPrintServiceByName(printerName));

                } catch (PrinterException e) {

                }

            }

            // Update attributes, this will preserve the page settings.

            //  - same code as in RasterPrinterJob.java

            updatePageAttributes(myService, pageClone);

            return pageClone;

        } else {

            return page;

        }

    }

    private boolean displayNativeDialog() {

        // "attributes" is required for getting the updated attributes

        if (attributes == null) {

            return false;

        }

        DialogOwner dlgOwner = (DialogOwner)attributes.get(DialogOwner.class);

        Frame ownerFrame = (dlgOwner != null) ? dlgOwner.getOwner() : null;

        WPrintDialog dialog = new WPrintDialog(ownerFrame, this);

        dialog.setRetVal(false);

        dialog.setVisible(true);

        boolean prv = dialog.getRetVal();

        dialog.dispose();

        Destination dest =

                (Destination)attributes.get(Destination.class);

        if ((dest == null) || !prv){

                return prv;

        } else {

            String title = null;

            String strBundle = "sun.print.resources.serviceui";

            ResourceBundle rb = ResourceBundle.getBundle(strBundle);

            try {

                title = rb.getString("dialog.printtofile");

            } catch (MissingResourceException e) {

            }

            FileDialog fileDialog = new FileDialog(ownerFrame, title,

                                                   FileDialog.SAVE);

            URI destURI = dest.getURI();

            // Old code destURI.getPath() would return null for "file:out.prn"

            // so we use getSchemeSpecificPart instead.

            String pathName = (destURI != null) ?

                destURI.getSchemeSpecificPart() : null;

            if (pathName != null) {

               File file = new File(pathName);

               fileDialog.setFile(file.getName());

               File parent = file.getParentFile();

               if (parent != null) {

                   fileDialog.setDirectory(parent.getPath());

               }

            } else {

                fileDialog.setFile("out.prn");

            }

            fileDialog.setVisible(true);

            String fileName = fileDialog.getFile();

            if (fileName == null) {

                fileDialog.dispose();

                return false;

            }

            String fullName = fileDialog.getDirectory() + fileName;

            File f = new File(fullName);

            File pFile = f.getParentFile();

            while ((f.exists() &&

                      (!f.isFile() || !f.canWrite())) ||

                   ((pFile != null) &&

                      (!pFile.exists() || (pFile.exists() && !pFile.canWrite())))) {

                (new PrintToFileErrorDialog(ownerFrame,

                                ServiceDialog.getMsg("dialog.owtitle"),

                                ServiceDialog.getMsg("dialog.writeerror")+" "+fullName,

                                ServiceDialog.getMsg("button.ok"))).setVisible(true);