Java tutorial
/* * Copyright (c) 1999, 2018, Oracle and/or its affiliates. All rights reserved. * 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 java.awt; /** * A set of attributes which control a print job. * <p> * Instances of this class control the number of copies, default selection, * destination, print dialog, file and printer names, page ranges, multiple * document handling (including collation), and multi-page imposition (such * as duplex) of every print job which uses the instance. Attribute names are * compliant with the Internet Printing Protocol (IPP) 1.1 where possible. * Attribute values are partially compliant where possible. * <p> * To use a method which takes an inner class type, pass a reference to * one of the constant fields of the inner class. Client code cannot create * new instances of the inner class types because none of those classes * has a public constructor. For example, to set the print dialog type to * the cross-platform, pure Java print dialog, use the following code: * <pre> * import java.awt.JobAttributes; * * public class PureJavaPrintDialogExample { * public void setPureJavaPrintDialog(JobAttributes jobAttributes) { * jobAttributes.setDialog(JobAttributes.DialogType.COMMON); * } * } * </pre> * <p> * Every IPP attribute which supports an <i>attributeName</i>-default value * has a corresponding <code>set<i>attributeName</i>ToDefault</code> method. * Default value fields are not provided. * * @author David Mendenhall * @since 1.3 */ public final class JobAttributes implements Cloneable { /** * A type-safe enumeration of possible default selection states. * @since 1.3 */ public static final class DefaultSelectionType extends AttributeValue { private static final int I_ALL = 0; private static final int I_RANGE = 1; private static final int I_SELECTION = 2; private static final String[] NAMES = { "all", "range", "selection" }; /** * The {@code DefaultSelectionType} instance to use for * specifying that all pages of the job should be printed. */ public static final DefaultSelectionType ALL = new DefaultSelectionType(I_ALL); /** * The {@code DefaultSelectionType} instance to use for * specifying that a range of pages of the job should be printed. */ public static final DefaultSelectionType RANGE = new DefaultSelectionType(I_RANGE); /** * The {@code DefaultSelectionType} instance to use for * specifying that the current selection should be printed. */ public static final DefaultSelectionType SELECTION = new DefaultSelectionType(I_SELECTION); private DefaultSelectionType(int type) { super(type, NAMES); } } /** * A type-safe enumeration of possible job destinations. * @since 1.3 */ public static final class DestinationType extends AttributeValue { private static final int I_FILE = 0; private static final int I_PRINTER = 1; private static final String[] NAMES = { "file", "printer" }; /** * The {@code DestinationType} instance to use for * specifying print to file. */ public static final DestinationType FILE = new DestinationType(I_FILE); /** * The {@code DestinationType} instance to use for * specifying print to printer. */ public static final DestinationType PRINTER = new DestinationType(I_PRINTER); private DestinationType(int type) { super(type, NAMES); } } /** * A type-safe enumeration of possible dialogs to display to the user. * @since 1.3 */ public static final class DialogType extends AttributeValue { private static final int I_COMMON = 0; private static final int I_NATIVE = 1; private static final int I_NONE = 2; private static final String[] NAMES = { "common", "native", "none" }; /** * The {@code DialogType} instance to use for * specifying the cross-platform, pure Java print dialog. */ public static final DialogType COMMON = new DialogType(I_COMMON); /** * The {@code DialogType} instance to use for * specifying the platform's native print dialog. */ public static final DialogType NATIVE = new DialogType(I_NATIVE); /** * The {@code DialogType} instance to use for * specifying no print dialog. */ public static final DialogType NONE = new DialogType(I_NONE); private DialogType(int type) { super(type, NAMES); } } /** * A type-safe enumeration of possible multiple copy handling states. * It is used to control how the sheets of multiple copies of a single * document are collated. * @since 1.3 */ public static final class MultipleDocumentHandlingType extends AttributeValue { private static final int I_SEPARATE_DOCUMENTS_COLLATED_COPIES = 0; private static final int I_SEPARATE_DOCUMENTS_UNCOLLATED_COPIES = 1; private static final String[] NAMES = { "separate-documents-collated-copies", "separate-documents-uncollated-copies" }; /** * The {@code MultipleDocumentHandlingType} instance to use for specifying * that the job should be divided into separate, collated copies. */ public static final MultipleDocumentHandlingType SEPARATE_DOCUMENTS_COLLATED_COPIES = new MultipleDocumentHandlingType( I_SEPARATE_DOCUMENTS_COLLATED_COPIES); /** * The {@code MultipleDocumentHandlingType} instance to use for specifying * that the job should be divided into separate, uncollated copies. */ public static final MultipleDocumentHandlingType SEPARATE_DOCUMENTS_UNCOLLATED_COPIES = new MultipleDocumentHandlingType( I_SEPARATE_DOCUMENTS_UNCOLLATED_COPIES); private MultipleDocumentHandlingType(int type) { super(type, NAMES); } } /** * A type-safe enumeration of possible multi-page impositions. These * impositions are in compliance with IPP 1.1. * @since 1.3 */ public static final class SidesType extends AttributeValue { private static final int I_ONE_SIDED = 0; private static final int I_TWO_SIDED_LONG_EDGE = 1; private static final int I_TWO_SIDED_SHORT_EDGE = 2; private static final String[] NAMES = { "one-sided", "two-sided-long-edge", "two-sided-short-edge" }; /** * The {@code SidesType} instance to use for specifying that * consecutive job pages should be printed upon the same side of * consecutive media sheets. */ public static final SidesType ONE_SIDED = new SidesType(I_ONE_SIDED); /** * The {@code SidesType} instance to use for specifying that * consecutive job pages should be printed upon front and back sides * of consecutive media sheets, such that the orientation of each pair * of pages on the medium would be correct for the reader as if for * binding on the long edge. */ public static final SidesType TWO_SIDED_LONG_EDGE = new SidesType(I_TWO_SIDED_LONG_EDGE); /** * The {@code SidesType} instance to use for specifying that * consecutive job pages should be printed upon front and back sides * of consecutive media sheets, such that the orientation of each pair * of pages on the medium would be correct for the reader as if for * binding on the short edge. */ public static final SidesType TWO_SIDED_SHORT_EDGE = new SidesType(I_TWO_SIDED_SHORT_EDGE); private SidesType(int type) { super(type, NAMES); } } private int copies; private DefaultSelectionType defaultSelection; private DestinationType destination; private DialogType dialog; private String fileName; private int fromPage; private int maxPage; private int minPage; private MultipleDocumentHandlingType multipleDocumentHandling; private int[][] pageRanges; private int prFirst; private int prLast; private String printer; private SidesType sides; private int toPage; /** * Constructs a {@code JobAttributes} instance with default * values for every attribute. The dialog defaults to * {@code DialogType.NATIVE}. Min page defaults to * {@code 1}. Max page defaults to {@code Integer.MAX_VALUE}. * Destination defaults to {@code DestinationType.PRINTER}. * Selection defaults to {@code DefaultSelectionType.ALL}. * Number of copies defaults to {@code 1}. Multiple document handling defaults * to {@code MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES}. * Sides defaults to {@code SidesType.ONE_SIDED}. File name defaults * to {@code null}. */ public JobAttributes() { setCopiesToDefault(); setDefaultSelection(DefaultSelectionType.ALL); setDestination(DestinationType.PRINTER); setDialog(DialogType.NATIVE); setMaxPage(Integer.MAX_VALUE); setMinPage(1); setMultipleDocumentHandlingToDefault(); setSidesToDefault(); } /** * Constructs a {@code JobAttributes} instance which is a copy * of the supplied {@code JobAttributes}. * * @param obj the {@code JobAttributes} to copy */ public JobAttributes(JobAttributes obj) { set(obj); } /** * Constructs a {@code JobAttributes} instance with the * specified values for every attribute. * * @param copies an integer greater than 0 * @param defaultSelection {@code DefaultSelectionType.ALL}, * {@code DefaultSelectionType.RANGE}, or * {@code DefaultSelectionType.SELECTION} * @param destination {@code DestinationType.FILE} or * {@code DestinationType.PRINTER} * @param dialog {@code DialogType.COMMON}, * {@code DialogType.NATIVE}, or * {@code DialogType.NONE} * @param fileName the possibly {@code null} file name * @param maxPage an integer greater than zero and greater than or equal * to <i>minPage</i> * @param minPage an integer greater than zero and less than or equal * to <i>maxPage</i> * @param multipleDocumentHandling * {@code MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES} or * {@code MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES} * @param pageRanges an array of integer arrays of two elements; an array * is interpreted as a range spanning all pages including and * between the specified pages; ranges must be in ascending * order and must not overlap; specified page numbers cannot be * less than <i>minPage</i> nor greater than <i>maxPage</i>; * for example: * <pre> * (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 }, * new int[] { 15, 19 } }), * </pre> * specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19. Note that * ({@code new int[][] { new int[] { 1, 1 }, new int[] { 1, 2 } }}), * is an invalid set of page ranges because the two ranges * overlap * @param printer the possibly {@code null} printer name * @param sides {@code SidesType.ONE_SIDED}, * {@code SidesType.TWO_SIDED_LONG_EDGE}, or * {@code SidesType.TWO_SIDED_SHORT_EDGE} * @throws IllegalArgumentException if one or more of the above * conditions is violated */ public JobAttributes(int copies, DefaultSelectionType defaultSelection, DestinationType destination, DialogType dialog, String fileName, int maxPage, int minPage, MultipleDocumentHandlingType multipleDocumentHandling, int[][] pageRanges, String printer, SidesType sides) { setCopies(copies); setDefaultSelection(defaultSelection); setDestination(destination); setDialog(dialog); setFileName(fileName); setMaxPage(maxPage); setMinPage(minPage); setMultipleDocumentHandling(multipleDocumentHandling); setPageRanges(pageRanges); setPrinter(printer); setSides(sides); } /** * Creates and returns a copy of this {@code JobAttributes}. * * @return the newly created copy; it is safe to cast this Object into * a {@code JobAttributes} */ public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException e) { // Since we implement Cloneable, this should never happen throw new InternalError(e); } } /** * Sets all of the attributes of this {@code JobAttributes} to * the same values as the attributes of obj. * * @param obj the {@code JobAttributes} to copy */ public void set(JobAttributes obj) { copies = obj.copies; defaultSelection = obj.defaultSelection; destination = obj.destination; dialog = obj.dialog; fileName = obj.fileName; fromPage = obj.fromPage; maxPage = obj.maxPage; minPage = obj.minPage; multipleDocumentHandling = obj.multipleDocumentHandling; // okay because we never modify the contents of pageRanges pageRanges = obj.pageRanges; prFirst = obj.prFirst; prLast = obj.prLast; printer = obj.printer; sides = obj.sides; toPage = obj.toPage; } /** * Returns the number of copies the application should render for jobs * using these attributes. This attribute is updated to the value chosen * by the user. * * @return an integer greater than 0. */ public int getCopies() { return copies; } /** * Specifies the number of copies the application should render for jobs * using these attributes. Not specifying this attribute is equivalent to * specifying {@code 1}. * * @param copies an integer greater than 0 * @throws IllegalArgumentException if {@code copies} is less than * or equal to 0 */ public void setCopies(int copies) { if (copies <= 0) { throw new IllegalArgumentException("Invalid value for attribute " + "copies"); } this.copies = copies; } /** * Sets the number of copies the application should render for jobs using * these attributes to the default. The default number of copies is 1. */ public void setCopiesToDefault() { setCopies(1); } /** * Specifies whether, for jobs using these attributes, the application * should print all pages, the range specified by the return value of * {@code getPageRanges}, or the current selection. This attribute * is updated to the value chosen by the user. * * @return DefaultSelectionType.ALL, DefaultSelectionType.RANGE, or * DefaultSelectionType.SELECTION */ public DefaultSelectionType getDefaultSelection() { return defaultSelection; } /** * Specifies whether, for jobs using these attributes, the application * should print all pages, the range specified by the return value of * {@code getPageRanges}, or the current selection. Not specifying * this attribute is equivalent to specifying DefaultSelectionType.ALL. * * @param defaultSelection DefaultSelectionType.ALL, * DefaultSelectionType.RANGE, or DefaultSelectionType.SELECTION. * @throws IllegalArgumentException if defaultSelection is {@code null} */ public void setDefaultSelection(DefaultSelectionType defaultSelection) { if (defaultSelection == null) { throw new IllegalArgumentException("Invalid value for attribute " + "defaultSelection"); } this.defaultSelection = defaultSelection; } /** * Specifies whether output will be to a printer or a file for jobs using * these attributes. This attribute is updated to the value chosen by the * user. * * @return DestinationType.FILE or DestinationType.PRINTER */ public DestinationType getDestination() { return destination; } /** * Specifies whether output will be to a printer or a file for jobs using * these attributes. Not specifying this attribute is equivalent to * specifying DestinationType.PRINTER. * * @param destination DestinationType.FILE or DestinationType.PRINTER. * @throws IllegalArgumentException if destination is null. */ public void setDestination(DestinationType destination) { if (destination == null) { throw new IllegalArgumentException("Invalid value for attribute " + "destination"); } this.destination = destination; } /** * Returns whether, for jobs using these attributes, the user should see * a print dialog in which to modify the print settings, and which type of * print dialog should be displayed. DialogType.COMMON denotes a cross- * platform, pure Java print dialog. DialogType.NATIVE denotes the * platform's native print dialog. If a platform does not support a native * print dialog, the pure Java print dialog is displayed instead. * DialogType.NONE specifies no print dialog (i.e., background printing). * This attribute cannot be modified by, and is not subject to any * limitations of, the implementation or the target printer. * * @return {@code DialogType.COMMON}, {@code DialogType.NATIVE}, or * {@code DialogType.NONE} */ public DialogType getDialog() { return dialog; } /** * Specifies whether, for jobs using these attributes, the user should see * a print dialog in which to modify the print settings, and which type of * print dialog should be displayed. DialogType.COMMON denotes a cross- * platform, pure Java print dialog. DialogType.NATIVE denotes the * platform's native print dialog. If a platform does not support a native * print dialog, the pure Java print dialog is displayed instead. * DialogType.NONE specifies no print dialog (i.e., background printing). * Not specifying this attribute is equivalent to specifying * DialogType.NATIVE. * * @param dialog DialogType.COMMON, DialogType.NATIVE, or * DialogType.NONE. * @throws IllegalArgumentException if dialog is null. */ public void setDialog(DialogType dialog) { if (dialog == null) { throw new IllegalArgumentException("Invalid value for attribute " + "dialog"); } this.dialog = dialog; } /** * Specifies the file name for the output file for jobs using these * attributes. This attribute is updated to the value chosen by the user. * * @return the possibly {@code null} file name */ public String getFileName() { return fileName; } /** * Specifies the file name for the output file for jobs using these * attributes. Default is platform-dependent and implementation-defined. * * @param fileName the possibly null file name. */ public void setFileName(String fileName) { this.fileName = fileName; } /** * Returns, for jobs using these attributes, the first page to be * printed, if a range of pages is to be printed. This attribute is * updated to the value chosen by the user. An application should ignore * this attribute on output, unless the return value of the * {@code getDefaultSelection} method is DefaultSelectionType.RANGE. An * application should honor the return value of {@code getPageRanges} * over the return value of this method, if possible. * * @return an integer greater than zero and less than or equal to * <i>toPage</i> and greater than or equal to <i>minPage</i> and * less than or equal to <i>maxPage</i>. */ public int getFromPage() { if (fromPage != 0) { return fromPage; } else if (toPage != 0) { return getMinPage(); } else if (pageRanges != null) { return prFirst; } else { return getMinPage(); } } /** * Specifies, for jobs using these attributes, the first page to be * printed, if a range of pages is to be printed. If this attribute is not * specified, then the values from the pageRanges attribute are used. If * pageRanges and either or both of fromPage and toPage are specified, * pageRanges takes precedence. Specifying none of pageRanges, fromPage, * or toPage is equivalent to calling * setPageRanges(new int[][] { new int[] { <i>minPage</i> } }); * * @param fromPage an integer greater than zero and less than or equal to * <i>toPage</i> and greater than or equal to <i>minPage</i> and * less than or equal to <i>maxPage</i>. * @throws IllegalArgumentException if one or more of the above * conditions is violated. */ public void setFromPage(int fromPage) { if (fromPage <= 0 || (toPage != 0 && fromPage > toPage) || fromPage < minPage || fromPage > maxPage) { throw new IllegalArgumentException("Invalid value for attribute " + "fromPage"); } this.fromPage = fromPage; } /** * Specifies the maximum value the user can specify as the last page to * be printed for jobs using these attributes. This attribute cannot be * modified by, and is not subject to any limitations of, the * implementation or the target printer. * * @return an integer greater than zero and greater than or equal * to <i>minPage</i>. */ public int getMaxPage() { return maxPage; } /** * Specifies the maximum value the user can specify as the last page to * be printed for jobs using these attributes. Not specifying this * attribute is equivalent to specifying {@code Integer.MAX_VALUE}. * * @param maxPage an integer greater than zero and greater than or equal * to <i>minPage</i> * @throws IllegalArgumentException if one or more of the above * conditions is violated */ public void setMaxPage(int maxPage) { if (maxPage <= 0 || maxPage < minPage) { throw new IllegalArgumentException("Invalid value for attribute " + "maxPage"); } this.maxPage = maxPage; } /** * Specifies the minimum value the user can specify as the first page to * be printed for jobs using these attributes. This attribute cannot be * modified by, and is not subject to any limitations of, the * implementation or the target printer. * * @return an integer greater than zero and less than or equal * to <i>maxPage</i>. */ public int getMinPage() { return minPage; } /** * Specifies the minimum value the user can specify as the first page to * be printed for jobs using these attributes. Not specifying this * attribute is equivalent to specifying {@code 1}. * * @param minPage an integer greater than zero and less than or equal * to <i>maxPage</i>. * @throws IllegalArgumentException if one or more of the above * conditions is violated. */ public void setMinPage(int minPage) { if (minPage <= 0 || minPage > maxPage) { throw new IllegalArgumentException("Invalid value for attribute " + "minPage"); } this.minPage = minPage; } /** * Specifies the handling of multiple copies, including collation, for * jobs using these attributes. This attribute is updated to the value * chosen by the user. * * @return * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES or * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES. */ public MultipleDocumentHandlingType getMultipleDocumentHandling() { return multipleDocumentHandling; } /** * Specifies the handling of multiple copies, including collation, for * jobs using these attributes. Not specifying this attribute is equivalent * to specifying * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES. * * @param multipleDocumentHandling * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES or * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES. * @throws IllegalArgumentException if multipleDocumentHandling is null. */ public void setMultipleDocumentHandling(MultipleDocumentHandlingType multipleDocumentHandling) { if (multipleDocumentHandling == null) { throw new IllegalArgumentException("Invalid value for attribute " + "multipleDocumentHandling"); } this.multipleDocumentHandling = multipleDocumentHandling; } /** * Sets the handling of multiple copies, including collation, for jobs * using these attributes to the default. The default handling is * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES. */ public void setMultipleDocumentHandlingToDefault() { setMultipleDocumentHandling(MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES); } /** * Specifies, for jobs using these attributes, the ranges of pages to be * printed, if a range of pages is to be printed. All range numbers are * inclusive. This attribute is updated to the value chosen by the user. * An application should ignore this attribute on output, unless the * return value of the {@code getDefaultSelection} method is * DefaultSelectionType.RANGE. * * @return an array of integer arrays of 2 elements. An array * is interpreted as a range spanning all pages including and * between the specified pages. Ranges must be in ascending * order and must not overlap. Specified page numbers cannot be * less than <i>minPage</i> nor greater than <i>maxPage</i>. * For example: * (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 }, * new int[] { 15, 19 } }), * specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19. */ public int[][] getPageRanges() { if (pageRanges != null) { // Return a copy because otherwise client code could circumvent the // the checks made in setPageRanges by modifying the returned // array. int[][] copy = new int[pageRanges.length][2]; for (int i = 0; i < pageRanges.length; i++) { copy[i][0] = pageRanges[i][0]; copy[i][1] = pageRanges[i][1]; } return copy; } else if (fromPage != 0 || toPage != 0) { int fromPage = getFromPage(); int toPage = getToPage(); return new int[][] { new int[] { fromPage, toPage } }; } else { int minPage = getMinPage(); return new int[][] { new int[] { minPage, minPage } }; } } /** * Specifies, for jobs using these attributes, the ranges of pages to be * printed, if a range of pages is to be printed. All range numbers are * inclusive. If this attribute is not specified, then the values from the * fromPage and toPages attributes are used. If pageRanges and either or * both of fromPage and toPage are specified, pageRanges takes precedence. * Specifying none of pageRanges, fromPage, or toPage is equivalent to * calling setPageRanges(new int[][] { new int[] { <i>minPage</i>, * <i>minPage</i> } }); * * @param pageRanges an array of integer arrays of 2 elements. An array * is interpreted as a range spanning all pages including and * between the specified pages. Ranges must be in ascending * order and must not overlap. Specified page numbers cannot be * less than <i>minPage</i> nor greater than <i>maxPage</i>. * For example: * (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 }, * new int[] { 15, 19 } }), * specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19. Note that * (new int[][] { new int[] { 1, 1 }, new int[] { 1, 2 } }), * is an invalid set of page ranges because the two ranges * overlap. * @throws IllegalArgumentException if one or more of the above * conditions is violated. */ public void setPageRanges(int[][] pageRanges) { String xcp = "Invalid value for attribute pageRanges"; int first = 0; int last = 0; if (pageRanges == null) { throw new IllegalArgumentException(xcp); } for (int i = 0; i < pageRanges.length; i++) { if (pageRanges[i] == null || pageRanges[i].length != 2 || pageRanges[i][0] <= last || pageRanges[i][1] < pageRanges[i][0]) { throw new IllegalArgumentException(xcp); } last = pageRanges[i][1]; if (first == 0) { first = pageRanges[i][0]; } } if (first < minPage || last > maxPage) { throw new IllegalArgumentException(xcp); } // Store a copy because otherwise client code could circumvent the // the checks made above by holding a reference to the array and // modifying it after calling setPageRanges. int[][] copy = new int[pageRanges.length][2]; for (int i = 0; i < pageRanges.length; i++) { copy[i][0] = pageRanges[i][0]; copy[i][1] = pageRanges[i][1]; } this.pageRanges = copy; this.prFirst = first; this.prLast = last; } /** * Returns the destination printer for jobs using these attributes. This * attribute is updated to the value chosen by the user. * * @return the possibly null printer name. */ public String getPrinter() { return printer; } /** * Specifies the destination printer for jobs using these attributes. * Default is platform-dependent and implementation-defined. * * @param printer the possibly null printer name. */ public void setPrinter(String printer) { this.printer = printer; } /** * Returns how consecutive pages should be imposed upon the sides of the * print medium for jobs using these attributes. SidesType.ONE_SIDED * imposes each consecutive page upon the same side of consecutive media * sheets. This imposition is sometimes called <i>simplex</i>. * SidesType.TWO_SIDED_LONG_EDGE imposes each consecutive pair of pages * upon front and back sides of consecutive media sheets, such that the * orientation of each pair of pages on the medium would be correct for * the reader as if for binding on the long edge. This imposition is * sometimes called <i>duplex</i>. SidesType.TWO_SIDED_SHORT_EDGE imposes * each consecutive pair of pages upon front and back sides of consecutive * media sheets, such that the orientation of each pair of pages on the * medium would be correct for the reader as if for binding on the short * edge. This imposition is sometimes called <i>tumble</i>. This attribute * is updated to the value chosen by the user. * * @return SidesType.ONE_SIDED, SidesType.TWO_SIDED_LONG_EDGE, or * SidesType.TWO_SIDED_SHORT_EDGE. */ public SidesType getSides() { return sides; } /** * Specifies how consecutive pages should be imposed upon the sides of the * print medium for jobs using these attributes. SidesType.ONE_SIDED * imposes each consecutive page upon the same side of consecutive media * sheets. This imposition is sometimes called <i>simplex</i>. * SidesType.TWO_SIDED_LONG_EDGE imposes each consecutive pair of pages * upon front and back sides of consecutive media sheets, such that the * orientation of each pair of pages on the medium would be correct for * the reader as if for binding on the long edge. This imposition is * sometimes called <i>duplex</i>. SidesType.TWO_SIDED_SHORT_EDGE imposes * each consecutive pair of pages upon front and back sides of consecutive * media sheets, such that the orientation of each pair of pages on the * medium would be correct for the reader as if for binding on the short * edge. This imposition is sometimes called <i>tumble</i>. Not specifying * this attribute is equivalent to specifying SidesType.ONE_SIDED. * * @param sides SidesType.ONE_SIDED, SidesType.TWO_SIDED_LONG_EDGE, or * SidesType.TWO_SIDED_SHORT_EDGE. * @throws IllegalArgumentException if sides is null. */ public void setSides(SidesType sides) { if (sides == null) { throw new IllegalArgumentException("Invalid value for attribute " + "sides"); } this.sides = sides; } /** * Sets how consecutive pages should be imposed upon the sides of the * print medium for jobs using these attributes to the default. The * default imposition is SidesType.ONE_SIDED. */ public void setSidesToDefault() { setSides(SidesType.ONE_SIDED); } /** * Returns, for jobs using these attributes, the last page (inclusive) * to be printed, if a range of pages is to be printed. This attribute is * updated to the value chosen by the user. An application should ignore * this attribute on output, unless the return value of the * {@code getDefaultSelection} method is DefaultSelectionType.RANGE. An * application should honor the return value of {@code getPageRanges} * over the return value of this method, if possible. * * @return an integer greater than zero and greater than or equal * to <i>toPage</i> and greater than or equal to <i>minPage</i> * and less than or equal to <i>maxPage</i>. */ public int getToPage() { if (toPage != 0) { return toPage; } else if (fromPage != 0) { return fromPage; } else if (pageRanges != null) { return prLast; } else { return getMinPage(); } } /** * Specifies, for jobs using these attributes, the last page (inclusive) * to be printed, if a range of pages is to be printed. * If this attribute is not specified, then the values from the pageRanges * attribute are used. If pageRanges and either or both of fromPage and * toPage are specified, pageRanges takes precedence. Specifying none of * pageRanges, fromPage, or toPage is equivalent to calling * setPageRanges(new int[][] { new int[] { <i>minPage</i> } }); * * @param toPage an integer greater than zero and greater than or equal * to <i>fromPage</i> and greater than or equal to <i>minPage</i> * and less than or equal to <i>maxPage</i>. * @throws IllegalArgumentException if one or more of the above * conditions is violated. */ public void setToPage(int toPage) { if (toPage <= 0 || (fromPage != 0 && toPage < fromPage) || toPage < minPage || toPage > maxPage) { throw new IllegalArgumentException("Invalid value for attribute " + "toPage"); } this.toPage = toPage; } /** * Determines whether two JobAttributes are equal to each other. * <p> * Two JobAttributes are equal if and only if each of their attributes are * equal. Attributes of enumeration type are equal if and only if the * fields refer to the same unique enumeration object. A set of page * ranges is equal if and only if the sets are of equal length, each range * enumerates the same pages, and the ranges are in the same order. * * @param obj the object whose equality will be checked. * @return whether obj is equal to this JobAttribute according to the * above criteria. */ public boolean equals(Object obj) { if (!(obj instanceof JobAttributes)) { return false; } JobAttributes rhs = (JobAttributes) obj; if (fileName == null) { if (rhs.fileName != null) { return false; } } else { if (!fileName.equals(rhs.fileName)) { return false; } } if (pageRanges == null) { if (rhs.pageRanges != null) { return false; } } else { if (rhs.pageRanges == null || pageRanges.length != rhs.pageRanges.length) { return false; } for (int i = 0; i < pageRanges.length; i++) { if (pageRanges[i][0] != rhs.pageRanges[i][0] || pageRanges[i][1] != rhs.pageRanges[i][1]) { return false; } } } if (printer == null) { if (rhs.printer != null) { return false; } } else { if (!printer.equals(rhs.printer)) { return false; } } return (copies == rhs.copies && defaultSelection == rhs.defaultSelection && destination == rhs.destination && dialog == rhs.dialog && fromPage == rhs.fromPage && maxPage == rhs.maxPage && minPage == rhs.minPage && multipleDocumentHandling == rhs.multipleDocumentHandling && prFirst == rhs.prFirst && prLast == rhs.prLast && sides == rhs.sides && toPage == rhs.toPage); } /** * Returns a hash code value for this JobAttributes. * * @return the hash code. */ public int hashCode() { int rest = ((copies + fromPage + maxPage + minPage + prFirst + prLast + toPage) * 31) << 21; if (pageRanges != null) { int sum = 0; for (int i = 0; i < pageRanges.length; i++) { sum += pageRanges[i][0] + pageRanges[i][1]; } rest ^= (sum * 31) << 11; } if (fileName != null) { rest ^= fileName.hashCode(); } if (printer != null) { rest ^= printer.hashCode(); } return (defaultSelection.hashCode() << 6 ^ destination.hashCode() << 5 ^ dialog.hashCode() << 3 ^ multipleDocumentHandling.hashCode() << 2 ^ sides.hashCode() ^ rest); } /** * Returns a string representation of this JobAttributes. * * @return the string representation. */ public String toString() { int[][] pageRanges = getPageRanges(); String prStr = "["; boolean first = true; for (int i = 0; i < pageRanges.length; i++) { if (first) { first = false; } else { prStr += ","; } prStr += pageRanges[i][0] + ":" + pageRanges[i][1]; } prStr += "]"; return "copies=" + getCopies() + ",defaultSelection=" + getDefaultSelection() + ",destination=" + getDestination() + ",dialog=" + getDialog() + ",fileName=" + getFileName() + ",fromPage=" + getFromPage() + ",maxPage=" + getMaxPage() + ",minPage=" + getMinPage() + ",multiple-document-handling=" + getMultipleDocumentHandling() + ",page-ranges=" + prStr + ",printer=" + getPrinter() + ",sides=" + getSides() + ",toPage=" + getToPage(); } }