| /* |
| * Copyright (c) 1999, 2006, 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</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(); |
| } |
| } |
| |
| /** |
| * 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(); |
| } |
| } |
