/*
 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

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</code> 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</code> 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</code> 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</code> instance to use for
 * specifying print to file.
 */
 public static final DestinationType FILE =
 new DestinationType(I_FILE);
 /**
 * The <code>DestinationType</code> 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</code> instance to use for
 * specifying the cross-platform, pure Java print dialog.
 */
 public static final DialogType COMMON = new DialogType(I_COMMON);
 /**
 * The <code>DialogType</code> instance to use for
 * specifying the platform's native print dialog.
 */
 public static final DialogType NATIVE = new DialogType(I_NATIVE);
 /**
 * The <code>DialogType</code> 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</code> 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</code> 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</code> 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</code> 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</code> 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</code> instance with default
 * values for every attribute. The dialog defaults to
 * <code>DialogType.NATIVE</code>. Min page defaults to
 * <code>1</code>. Max page defaults to <code>Integer.MAX_VALUE</code>.
 * Destination defaults to <code>DestinationType.PRINTER</code>.
 * Selection defaults to <code>DefaultSelectionType.ALL</code>.
 * Number of copies defaults to <code>1</code>. Multiple document handling defaults
 * to <code>MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES</code>.
 * Sides defaults to <code>SidesType.ONE_SIDED</code>. File name defaults
 * to <code>null</code>.
 */
 public JobAttributes() {
 setCopiesToDefault();
 setDefaultSelection(DefaultSelectionType.ALL);
 setDestination(DestinationType.PRINTER);
 setDialog(DialogType.NATIVE);
 setMaxPage(Integer.MAX_VALUE);
 setMinPage(1);
 setMultipleDocumentHandlingToDefault();
 setSidesToDefault();
 }

 /**
 * Constructs a <code>JobAttributes</code> instance which is a copy
 * of the supplied <code>JobAttributes</code>.
 *
 * @param obj the <code>JobAttributes</code> to copy
 */
 public JobAttributes(JobAttributes obj) {
 set(obj);
 }

 /**
 * Constructs a <code>JobAttributes</code> instance with the
 * specified values for every attribute.
 *
 * @param copies an integer greater than 0
 * @param defaultSelection <code>DefaultSelectionType.ALL</code>,
 * <code>DefaultSelectionType.RANGE</code>, or
 * <code>DefaultSelectionType.SELECTION</code>
 * @param destination <code>DesintationType.FILE</code> or
 * <code>DesintationType.PRINTER</code>
 * @param dialog <code>DialogType.COMMON</code>,
 * <code>DialogType.NATIVE</code>, or
 * <code>DialogType.NONE</code>
 * @param fileName the possibly <code>null</code> 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</code> or
 * <code>MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES</code>
 * @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 } }</code>),
 * is an invalid set of page ranges because the two ranges
 * overlap
 * @param printer the possibly <code>null</code> printer name
 * @param sides <code>SidesType.ONE_SIDED</code>,
 * <code>SidesType.TWO_SIDED_LONG_EDGE</code>, or
 * <code>SidesType.TWO_SIDED_SHORT_EDGE</code>
 * @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</code>.
 *
 * @return the newly created copy; it is safe to cast this Object into
 * a <code>JobAttributes</code>
 */
 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</code> to
 * the same values as the attributes of obj.
 *
 * @param obj the <code>JobAttributes</code> 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</code>.
 *
 * @param copies an integer greater than 0
 * @throws IllegalArgumentException if <code>copies</code> 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</code>, 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</code>, 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</code>
 */
 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 DesintationType.FILE or DesintationType.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 DesintationType.PRINTER.
 *
 * @param destination DesintationType.FILE or DesintationType.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>, <code>DialogType.NATIVE</code>, or
 * <code>DialogType.NONE</code>
 */
 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</code> 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</code> method is DefaultSelectionType.RANGE. An
 * application should honor the return value of <code>getPageRanges</code>
 * 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</code>.
 *
 * @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</code>.
 *
 * @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</code> 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</code> method is DefaultSelectionType.RANGE. An
 * application should honor the return value of <code>getPageRanges</code>
 * 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();
 }
}