Back to index...

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

Back to index...