JDK14/Java14源码在线阅读
/*
* Copyright (c) 1999, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.awt;
/**
* A set of attributes which control a print job.
* <p>
* Instances of this class control the number of copies, default selection,
* destination, print dialog, file and printer names, page ranges, multiple
* document handling (including collation), and multi-page imposition (such
* as duplex) of every print job which uses the instance. Attribute names are
* compliant with the Internet Printing Protocol (IPP) 1.1 where possible.
* Attribute values are partially compliant where possible.
* <p>
* To use a method which takes an inner class type, pass a reference to
* one of the constant fields of the inner class. Client code cannot create
* new instances of the inner class types because none of those classes
* has a public constructor. For example, to set the print dialog type to
* the cross-platform, pure Java print dialog, use the following code:
* <pre>
* import java.awt.JobAttributes;
*
* public class PureJavaPrintDialogExample {
* public void setPureJavaPrintDialog(JobAttributes jobAttributes) {
* jobAttributes.setDialog(JobAttributes.DialogType.COMMON);
* }
* }
* </pre>
* <p>
* Every IPP attribute which supports an <i>attributeName</i>-default value
* has a corresponding <code>set<i>attributeName</i>ToDefault</code> method.
* Default value fields are not provided.
*
* @author David Mendenhall
* @since 1.3
*/
public final class JobAttributes implements Cloneable {
/**
* A type-safe enumeration of possible default selection states.
* @since 1.3
*/
public static final class DefaultSelectionType extends AttributeValue {
private static final int I_ALL = 0;
private static final int I_RANGE = 1;
private static final int I_SELECTION = 2;
private static final String[] NAMES = {
"all", "range", "selection"
};
/**
* The {@code DefaultSelectionType} instance to use for
* specifying that all pages of the job should be printed.
*/
public static final DefaultSelectionType ALL =
new DefaultSelectionType(I_ALL);
/**
* The {@code DefaultSelectionType} instance to use for
* specifying that a range of pages of the job should be printed.
*/
public static final DefaultSelectionType RANGE =
new DefaultSelectionType(I_RANGE);
/**
* The {@code DefaultSelectionType} instance to use for
* specifying that the current selection should be printed.
*/
public static final DefaultSelectionType SELECTION =
new DefaultSelectionType(I_SELECTION);
private DefaultSelectionType(int type) {
super(type, NAMES);
}
}
/**
* A type-safe enumeration of possible job destinations.
* @since 1.3
*/
public static final class DestinationType extends AttributeValue {
private static final int I_FILE = 0;
private static final int I_PRINTER = 1;
private static final String[] NAMES = {
"file", "printer"
};
/**
* The {@code DestinationType} instance to use for
* specifying print to file.
*/
public static final DestinationType FILE =
new DestinationType(I_FILE);
/**
* The {@code DestinationType} instance to use for
* specifying print to printer.
*/
public static final DestinationType PRINTER =
new DestinationType(I_PRINTER);
private DestinationType(int type) {
super(type, NAMES);
}
}
/**
* A type-safe enumeration of possible dialogs to display to the user.
* @since 1.3
*/
public static final class DialogType extends AttributeValue {
private static final int I_COMMON = 0;
private static final int I_NATIVE = 1;
private static final int I_NONE = 2;
private static final String[] NAMES = {
"common", "native", "none"
};
/**
* The {@code DialogType} instance to use for
* specifying the cross-platform, pure Java print dialog.
*/
public static final DialogType COMMON = new DialogType(I_COMMON);
/**
* The {@code DialogType} instance to use for
* specifying the platform's native print dialog.
*/
public static final DialogType NATIVE = new DialogType(I_NATIVE);
/**
* The {@code DialogType} instance to use for
* specifying no print dialog.
*/
public static final DialogType NONE = new DialogType(I_NONE);
private DialogType(int type) {
super(type, NAMES);
}
}
/**
* A type-safe enumeration of possible multiple copy handling states.
* It is used to control how the sheets of multiple copies of a single
* document are collated.
* @since 1.3
*/
public static final class MultipleDocumentHandlingType extends
AttributeValue {
private static final int I_SEPARATE_DOCUMENTS_COLLATED_COPIES = 0;
private static final int I_SEPARATE_DOCUMENTS_UNCOLLATED_COPIES = 1;
private static final String[] NAMES = {
"separate-documents-collated-copies",
"separate-documents-uncollated-copies"
};
/**
* The {@code MultipleDocumentHandlingType} instance to use for specifying
* that the job should be divided into separate, collated copies.
*/
public static final MultipleDocumentHandlingType
SEPARATE_DOCUMENTS_COLLATED_COPIES =
new MultipleDocumentHandlingType(
I_SEPARATE_DOCUMENTS_COLLATED_COPIES);
/**
* The {@code MultipleDocumentHandlingType} instance to use for specifying
* that the job should be divided into separate, uncollated copies.
*/
public static final MultipleDocumentHandlingType
SEPARATE_DOCUMENTS_UNCOLLATED_COPIES =
new MultipleDocumentHandlingType(
I_SEPARATE_DOCUMENTS_UNCOLLATED_COPIES);
private MultipleDocumentHandlingType(int type) {
super(type, NAMES);
}
}
/**
* A type-safe enumeration of possible multi-page impositions. These
* impositions are in compliance with IPP 1.1.
* @since 1.3
*/
public static final class SidesType extends AttributeValue {
private static final int I_ONE_SIDED = 0;
private static final int I_TWO_SIDED_LONG_EDGE = 1;
private static final int I_TWO_SIDED_SHORT_EDGE = 2;
private static final String[] NAMES = {
"one-sided", "two-sided-long-edge", "two-sided-short-edge"
};
/**
* The {@code SidesType} instance to use for specifying that
* consecutive job pages should be printed upon the same side of
* consecutive media sheets.
*/
public static final SidesType ONE_SIDED = new SidesType(I_ONE_SIDED);
/**
* The {@code SidesType} instance to use for specifying that
* consecutive job pages should be printed upon front and back sides
* of consecutive media sheets, such that the orientation of each pair
* of pages on the medium would be correct for the reader as if for
* binding on the long edge.
*/
public static final SidesType TWO_SIDED_LONG_EDGE =
new SidesType(I_TWO_SIDED_LONG_EDGE);
/**
* The {@code SidesType} instance to use for specifying that
* consecutive job pages should be printed upon front and back sides
* of consecutive media sheets, such that the orientation of each pair
* of pages on the medium would be correct for the reader as if for
* binding on the short edge.
*/
public static final SidesType TWO_SIDED_SHORT_EDGE =
new SidesType(I_TWO_SIDED_SHORT_EDGE);
private SidesType(int type) {
super(type, NAMES);
}
}
private int copies;
private DefaultSelectionType defaultSelection;
private DestinationType destination;
private DialogType dialog;
private String fileName;
private int fromPage;
private int maxPage;
private int minPage;
private MultipleDocumentHandlingType multipleDocumentHandling;
private int[][] pageRanges;
private int prFirst;
private int prLast;
private String printer;
private SidesType sides;
private int toPage;
/**
* Constructs a {@code JobAttributes} instance with default
* values for every attribute. The dialog defaults to
* {@code DialogType.NATIVE}. Min page defaults to
* {@code 1}. Max page defaults to {@code Integer.MAX_VALUE}.
* Destination defaults to {@code DestinationType.PRINTER}.
* Selection defaults to {@code DefaultSelectionType.ALL}.
* Number of copies defaults to {@code 1}. Multiple document handling defaults
* to {@code MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES}.
* Sides defaults to {@code SidesType.ONE_SIDED}. File name defaults
* to {@code null}.
*/
public JobAttributes() {
setCopiesToDefault();
setDefaultSelection(DefaultSelectionType.ALL);
setDestination(DestinationType.PRINTER);
setDialog(DialogType.NATIVE);
setMaxPage(Integer.MAX_VALUE);
setMinPage(1);
setMultipleDocumentHandlingToDefault();
setSidesToDefault();
}
/**
* Constructs a {@code JobAttributes} instance which is a copy
* of the supplied {@code JobAttributes}.
*
* @param obj the {@code JobAttributes} to copy
*/
public JobAttributes(JobAttributes obj) {
set(obj);
}
/**
* Constructs a {@code JobAttributes} instance with the
* specified values for every attribute.
*
* @param copies an integer greater than 0
* @param defaultSelection {@code DefaultSelectionType.ALL},
* {@code DefaultSelectionType.RANGE}, or
* {@code DefaultSelectionType.SELECTION}
* @param destination {@code DestinationType.FILE} or
* {@code DestinationType.PRINTER}
* @param dialog {@code DialogType.COMMON},
* {@code DialogType.NATIVE}, or
* {@code DialogType.NONE}
* @param fileName the possibly {@code null} file name
* @param maxPage an integer greater than zero and greater than or equal
* to <i>minPage</i>
* @param minPage an integer greater than zero and less than or equal
* to <i>maxPage</i>
* @param multipleDocumentHandling
* {@code MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES} or
* {@code MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES}
* @param pageRanges an array of integer arrays of two elements; an array
* is interpreted as a range spanning all pages including and
* between the specified pages; ranges must be in ascending
* order and must not overlap; specified page numbers cannot be
* less than <i>minPage</i> nor greater than <i>maxPage</i>;
* for example:
* <pre>
* (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 },
* new int[] { 15, 19 } }),
* </pre>
* specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19. Note that
* ({@code new int[][] { new int[] { 1, 1 }, new int[] { 1, 2 } }}),
* is an invalid set of page ranges because the two ranges
* overlap
* @param printer the possibly {@code null} printer name
* @param sides {@code SidesType.ONE_SIDED},
* {@code SidesType.TWO_SIDED_LONG_EDGE}, or
* {@code SidesType.TWO_SIDED_SHORT_EDGE}
* @throws IllegalArgumentException if one or more of the above
* conditions is violated
*/
public JobAttributes(int copies, DefaultSelectionType defaultSelection,
DestinationType destination, DialogType dialog,
String fileName, int maxPage, int minPage,
MultipleDocumentHandlingType multipleDocumentHandling,
int[][] pageRanges, String printer, SidesType sides) {
setCopies(copies);
setDefaultSelection(defaultSelection);
setDestination(destination);
setDialog(dialog);
setFileName(fileName);
setMaxPage(maxPage);
setMinPage(minPage);
setMultipleDocumentHandling(multipleDocumentHandling);
setPageRanges(pageRanges);
setPrinter(printer);
setSides(sides);
}
/**
* Creates and returns a copy of this {@code JobAttributes}.
*
* @return the newly created copy; it is safe to cast this Object into
* a {@code JobAttributes}
*/
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// Since we implement Cloneable, this should never happen
throw new InternalError(e);
}
}
/**
* Sets all of the attributes of this {@code JobAttributes} to
* the same values as the attributes of obj.
*
* @param obj the {@code JobAttributes} to copy
*/
public void set(JobAttributes obj) {
copies = obj.copies;
defaultSelection = obj.defaultSelection;
destination = obj.destination;
dialog = obj.dialog;
fileName = obj.fileName;
fromPage = obj.fromPage;
maxPage = obj.maxPage;
minPage = obj.minPage;
multipleDocumentHandling = obj.multipleDocumentHandling;
// okay because we never modify the contents of pageRanges
pageRanges = obj.pageRanges;
prFirst = obj.prFirst;
prLast = obj.prLast;
printer = obj.printer;
sides = obj.sides;
toPage = obj.toPage;
}
/**
* Returns the number of copies the application should render for jobs
* using these attributes. This attribute is updated to the value chosen
* by the user.
*
* @return an integer greater than 0.
*/
public int getCopies() {
return copies;
}
/**
* Specifies the number of copies the application should render for jobs
* using these attributes. Not specifying this attribute is equivalent to
* specifying {@code 1}.
*
* @param copies an integer greater than 0
* @throws IllegalArgumentException if {@code copies} is less than
* or equal to 0
*/
public void setCopies(int copies) {
if (copies <= 0) {
throw new IllegalArgumentException("Invalid value for attribute "+
"copies");
}
this.copies = copies;
}
/**
* Sets the number of copies the application should render for jobs using
* these attributes to the default. The default number of copies is 1.
*/
public void setCopiesToDefault() {
setCopies(1);
}
/**
* Specifies whether, for jobs using these attributes, the application
* should print all pages, the range specified by the return value of
* {@code getPageRanges}, or the current selection. This attribute
* is updated to the value chosen by the user.
*
* @return DefaultSelectionType.ALL, DefaultSelectionType.RANGE, or
* DefaultSelectionType.SELECTION
*/
public DefaultSelectionType getDefaultSelection() {
return defaultSelection;
}
/**
* Specifies whether, for jobs using these attributes, the application
* should print all pages, the range specified by the return value of
* {@code getPageRanges}, or the current selection. Not specifying
* this attribute is equivalent to specifying DefaultSelectionType.ALL.
*
* @param defaultSelection DefaultSelectionType.ALL,
* DefaultSelectionType.RANGE, or DefaultSelectionType.SELECTION.
* @throws IllegalArgumentException if defaultSelection is {@code null}
*/
public void setDefaultSelection(DefaultSelectionType defaultSelection) {
if (defaultSelection == null) {
throw new IllegalArgumentException("Invalid value for attribute "+
"defaultSelection");
}
this.defaultSelection = defaultSelection;
}
/**
* Specifies whether output will be to a printer or a file for jobs using
* these attributes. This attribute is updated to the value chosen by the
* user.
*
* @return DestinationType.FILE or DestinationType.PRINTER
*/
public DestinationType getDestination() {
return destination;
}
/**
* Specifies whether output will be to a printer or a file for jobs using
* these attributes. Not specifying this attribute is equivalent to
* specifying DestinationType.PRINTER.
*
* @param destination DestinationType.FILE or DestinationType.PRINTER.
* @throws IllegalArgumentException if destination is null.
*/
public void setDestination(DestinationType destination) {
if (destination == null) {
throw new IllegalArgumentException("Invalid value for attribute "+
"destination");
}
this.destination = destination;
}
/**
* Returns whether, for jobs using these attributes, the user should see
* a print dialog in which to modify the print settings, and which type of
* print dialog should be displayed. DialogType.COMMON denotes a cross-
* platform, pure Java print dialog. DialogType.NATIVE denotes the
* platform's native print dialog. If a platform does not support a native
* print dialog, the pure Java print dialog is displayed instead.
* DialogType.NONE specifies no print dialog (i.e., background printing).
* This attribute cannot be modified by, and is not subject to any
* limitations of, the implementation or the target printer.
*
* @return {@code DialogType.COMMON}, {@code DialogType.NATIVE}, or
* {@code DialogType.NONE}
*/
public DialogType getDialog() {
return dialog;
}
/**
* Specifies whether, for jobs using these attributes, the user should see
* a print dialog in which to modify the print settings, and which type of
* print dialog should be displayed. DialogType.COMMON denotes a cross-
* platform, pure Java print dialog. DialogType.NATIVE denotes the
* platform's native print dialog. If a platform does not support a native
* print dialog, the pure Java print dialog is displayed instead.
* DialogType.NONE specifies no print dialog (i.e., background printing).
* Not specifying this attribute is equivalent to specifying
* DialogType.NATIVE.
*
* @param dialog DialogType.COMMON, DialogType.NATIVE, or
* DialogType.NONE.
* @throws IllegalArgumentException if dialog is null.
*/
public void setDialog(DialogType dialog) {
if (dialog == null) {
throw new IllegalArgumentException("Invalid value for attribute "+
"dialog");
}
this.dialog = dialog;
}
/**
* Specifies the file name for the output file for jobs using these
* attributes. This attribute is updated to the value chosen by the user.
*
* @return the possibly {@code null} file name
*/
public String getFileName() {
return fileName;
}
/**
* Specifies the file name for the output file for jobs using these
* attributes. Default is platform-dependent and implementation-defined.
*
* @param fileName the possibly null file name.
*/
public void setFileName(String fileName) {
this.fileName = fileName;
}
/**
* Returns, for jobs using these attributes, the first page to be
* printed, if a range of pages is to be printed. This attribute is
* updated to the value chosen by the user. An application should ignore
* this attribute on output, unless the return value of the
* {@code getDefaultSelection} method is DefaultSelectionType.RANGE. An
* application should honor the return value of {@code getPageRanges}
* over the return value of this method, if possible.
*
* @return an integer greater than zero and less than or equal to
* <i>toPage</i> and greater than or equal to <i>minPage</i> and
* less than or equal to <i>maxPage</i>.
*/
public int getFromPage() {
if (fromPage != 0) {
return fromPage;
} else if (toPage != 0) {
return getMinPage();
} else if (pageRanges != null) {
return prFirst;
} else {
return getMinPage();
}
}
/**
* Specifies, for jobs using these attributes, the first page to be
* printed, if a range of pages is to be printed. If this attribute is not
* specified, then the values from the pageRanges attribute are used. If
* pageRanges and either or both of fromPage and toPage are specified,
* pageRanges takes precedence. Specifying none of pageRanges, fromPage,
* or toPage is equivalent to calling
* setPageRanges(new int[][] { new int[] { <i>minPage</i> } });
*
* @param fromPage an integer greater than zero and less than or equal to
* <i>toPage</i> and greater than or equal to <i>minPage</i> and
* less than or equal to <i>maxPage</i>.
* @throws IllegalArgumentException if one or more of the above
* conditions is violated.
*/
public void setFromPage(int fromPage) {
if (fromPage <= 0 ||
(toPage != 0 && fromPage > toPage) ||
fromPage < minPage ||
fromPage > maxPage) {
throw new IllegalArgumentException("Invalid value for attribute "+
"fromPage");
}
this.fromPage = fromPage;
}
/**
* Specifies the maximum value the user can specify as the last page to
* be printed for jobs using these attributes. This attribute cannot be
* modified by, and is not subject to any limitations of, the
* implementation or the target printer.
*
* @return an integer greater than zero and greater than or equal
* to <i>minPage</i>.
*/
public int getMaxPage() {
return maxPage;
}
/**
* Specifies the maximum value the user can specify as the last page to
* be printed for jobs using these attributes. Not specifying this
* attribute is equivalent to specifying {@code Integer.MAX_VALUE}.
*
* @param maxPage an integer greater than zero and greater than or equal
* to <i>minPage</i>
* @throws IllegalArgumentException if one or more of the above
* conditions is violated
*/
public void setMaxPage(int maxPage) {
if (maxPage <= 0 || maxPage < minPage) {
throw new IllegalArgumentException("Invalid value for attribute "+
"maxPage");
}
this.maxPage = maxPage;
}
/**
* Specifies the minimum value the user can specify as the first page to
* be printed for jobs using these attributes. This attribute cannot be
* modified by, and is not subject to any limitations of, the
* implementation or the target printer.
*
* @return an integer greater than zero and less than or equal
* to <i>maxPage</i>.
*/
public int getMinPage() {
return minPage;
}
/**
* Specifies the minimum value the user can specify as the first page to
* be printed for jobs using these attributes. Not specifying this
* attribute is equivalent to specifying {@code 1}.
*
* @param minPage an integer greater than zero and less than or equal
* to <i>maxPage</i>.
* @throws IllegalArgumentException if one or more of the above
* conditions is violated.
*/
public void setMinPage(int minPage) {
if (minPage <= 0 || minPage > maxPage) {
throw new IllegalArgumentException("Invalid value for attribute "+
"minPage");
}
this.minPage = minPage;
}
/**
* Specifies the handling of multiple copies, including collation, for
* jobs using these attributes. This attribute is updated to the value
* chosen by the user.
*
* @return
* MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES or
* MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES.
*/
public MultipleDocumentHandlingType getMultipleDocumentHandling() {
return multipleDocumentHandling;
}
/**
* Specifies the handling of multiple copies, including collation, for
* jobs using these attributes. Not specifying this attribute is equivalent
* to specifying
* MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES.
*
* @param multipleDocumentHandling
* MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES or
* MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES.
* @throws IllegalArgumentException if multipleDocumentHandling is null.
*/
public void setMultipleDocumentHandling(MultipleDocumentHandlingType
multipleDocumentHandling) {
if (multipleDocumentHandling == null) {
throw new IllegalArgumentException("Invalid value for attribute "+
"multipleDocumentHandling");
}
this.multipleDocumentHandling = multipleDocumentHandling;
}
/**
* Sets the handling of multiple copies, including collation, for jobs
* using these attributes to the default. The default handling is
* MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES.
*/
public void setMultipleDocumentHandlingToDefault() {
setMultipleDocumentHandling(
MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES);
}
/**
* Specifies, for jobs using these attributes, the ranges of pages to be
* printed, if a range of pages is to be printed. All range numbers are
* inclusive. This attribute is updated to the value chosen by the user.
* An application should ignore this attribute on output, unless the
* return value of the {@code getDefaultSelection} method is
* DefaultSelectionType.RANGE.
*
* @return an array of integer arrays of 2 elements. An array
* is interpreted as a range spanning all pages including and
* between the specified pages. Ranges must be in ascending
* order and must not overlap. Specified page numbers cannot be
* less than <i>minPage</i> nor greater than <i>maxPage</i>.
* For example:
* (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 },
* new int[] { 15, 19 } }),
* specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19.
*/
public int[][] getPageRanges() {
if (pageRanges != null) {
// Return a copy because otherwise client code could circumvent the
// the checks made in setPageRanges by modifying the returned
// array.
int[][] copy = new int[pageRanges.length][2];
for (int i = 0; i < pageRanges.length; i++) {
copy[i][0] = pageRanges[i][0];
copy[i][1] = pageRanges[i][1];
}
return copy;
} else if (fromPage != 0 || toPage != 0) {
int fromPage = getFromPage();
int toPage = getToPage();
return new int[][] { new int[] { fromPage, toPage } };
} else {
int minPage = getMinPage();
return new int[][] { new int[] { minPage, minPage } };
}
}
/**
* Specifies, for jobs using these attributes, the ranges of pages to be
* printed, if a range of pages is to be printed. All range numbers are
* inclusive. If this attribute is not specified, then the values from the
* fromPage and toPages attributes are used. If pageRanges and either or
* both of fromPage and toPage are specified, pageRanges takes precedence.
* Specifying none of pageRanges, fromPage, or toPage is equivalent to
* calling setPageRanges(new int[][] { new int[] { <i>minPage</i>,
* <i>minPage</i> } });
*
* @param pageRanges an array of integer arrays of 2 elements. An array
* is interpreted as a range spanning all pages including and
* between the specified pages. Ranges must be in ascending
* order and must not overlap. Specified page numbers cannot be
* less than <i>minPage</i> nor greater than <i>maxPage</i>.
* For example:
* (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 },
* new int[] { 15, 19 } }),
* specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19. Note that
* (new int[][] { new int[] { 1, 1 }, new int[] { 1, 2 } }),
* is an invalid set of page ranges because the two ranges
* overlap.
* @throws IllegalArgumentException if one or more of the above
* conditions is violated.
*/
public void setPageRanges(int[][] pageRanges) {
String xcp = "Invalid value for attribute pageRanges";
int first = 0;
int last = 0;
if (pageRanges == null) {
throw new IllegalArgumentException(xcp);
}
for (int i = 0; i < pageRanges.length; i++) {
if (pageRanges[i] == null ||
pageRanges[i].length != 2 ||
pageRanges[i][0] <= last ||
pageRanges[i][1] < pageRanges[i][0]) {
throw new IllegalArgumentException(xcp);
}
last = pageRanges[i][1];
if (first == 0) {
first = pageRanges[i][0];
}
}
if (first < minPage || last > maxPage) {
throw new IllegalArgumentException(xcp);
}
// Store a copy because otherwise client code could circumvent the
// the checks made above by holding a reference to the array and
// modifying it after calling setPageRanges.
int[][] copy = new int[pageRanges.length][2];
for (int i = 0; i < pageRanges.length; i++) {
copy[i][0] = pageRanges[i][0];
copy[i][1] = pageRanges[i][1];
}
this.pageRanges = copy;
this.prFirst = first;
this.prLast = last;
}
/**
* Returns the destination printer for jobs using these attributes. This
* attribute is updated to the value chosen by the user.
*
* @return the possibly null printer name.
*/
public String getPrinter() {
return printer;
}
/**
* Specifies the destination printer for jobs using these attributes.
* Default is platform-dependent and implementation-defined.
*
* @param printer the possibly null printer name.
*/
public void setPrinter(String printer) {
this.printer = printer;
}
/**
* Returns how consecutive pages should be imposed upon the sides of the
* print medium for jobs using these attributes. SidesType.ONE_SIDED
* imposes each consecutive page upon the same side of consecutive media
* sheets. This imposition is sometimes called <i>simplex</i>.
* SidesType.TWO_SIDED_LONG_EDGE imposes each consecutive pair of pages
* upon front and back sides of consecutive media sheets, such that the
* orientation of each pair of pages on the medium would be correct for
* the reader as if for binding on the long edge. This imposition is
* sometimes called <i>duplex</i>. SidesType.TWO_SIDED_SHORT_EDGE imposes
* each consecutive pair of pages upon front and back sides of consecutive
* media sheets, such that the orientation of each pair of pages on the
* medium would be correct for the reader as if for binding on the short
* edge. This imposition is sometimes called <i>tumble</i>. This attribute
* is updated to the value chosen by the user.
*
* @return SidesType.ONE_SIDED, SidesType.TWO_SIDED_LONG_EDGE, or
* SidesType.TWO_SIDED_SHORT_EDGE.
*/
public SidesType getSides() {
return sides;
}
/**
* Specifies how consecutive pages should be imposed upon the sides of the
* print medium for jobs using these attributes. SidesType.ONE_SIDED
* imposes each consecutive page upon the same side of consecutive media
* sheets. This imposition is sometimes called <i>simplex</i>.
* SidesType.TWO_SIDED_LONG_EDGE imposes each consecutive pair of pages
* upon front and back sides of consecutive media sheets, such that the
* orientation of each pair of pages on the medium would be correct for
* the reader as if for binding on the long edge. This imposition is
* sometimes called <i>duplex</i>. SidesType.TWO_SIDED_SHORT_EDGE imposes
* each consecutive pair of pages upon front and back sides of consecutive
* media sheets, such that the orientation of each pair of pages on the
* medium would be correct for the reader as if for binding on the short
* edge. This imposition is sometimes called <i>tumble</i>. Not specifying
* this attribute is equivalent to specifying SidesType.ONE_SIDED.
*
* @param sides SidesType.ONE_SIDED, SidesType.TWO_SIDED_LONG_EDGE, or
* SidesType.TWO_SIDED_SHORT_EDGE.
* @throws IllegalArgumentException if sides is null.
*/
public void setSides(SidesType sides) {
if (sides == null) {
throw new IllegalArgumentException("Invalid value for attribute "+
"sides");
}
this.sides = sides;
}
/**
* Sets how consecutive pages should be imposed upon the sides of the
* print medium for jobs using these attributes to the default. The
* default imposition is SidesType.ONE_SIDED.
*/
public void setSidesToDefault() {
setSides(SidesType.ONE_SIDED);
}
/**
* Returns, for jobs using these attributes, the last page (inclusive)
* to be printed, if a range of pages is to be printed. This attribute is
* updated to the value chosen by the user. An application should ignore
* this attribute on output, unless the return value of the
* {@code getDefaultSelection} method is DefaultSelectionType.RANGE. An
* application should honor the return value of {@code getPageRanges}
* over the return value of this method, if possible.
*
* @return an integer greater than zero and greater than or equal
* to <i>toPage</i> and greater than or equal to <i>minPage</i>
* and less than or equal to <i>maxPage</i>.
*/
public int getToPage() {
if (toPage != 0) {
return toPage;
} else if (fromPage != 0) {
return fromPage;
} else if (pageRanges != null) {
return prLast;
} else {
return getMinPage();
}
}
/**
* Specifies, for jobs using these attributes, the last page (inclusive)
* to be printed, if a range of pages is to be printed.
* If this attribute is not specified, then the values from the pageRanges
* attribute are used. If pageRanges and either or both of fromPage and
* toPage are specified, pageRanges takes precedence. Specifying none of
* pageRanges, fromPage, or toPage is equivalent to calling
* setPageRanges(new int[][] { new int[] { <i>minPage</i> } });
*
* @param toPage an integer greater than zero and greater than or equal
* to <i>fromPage</i> and greater than or equal to <i>minPage</i>
* and less than or equal to <i>maxPage</i>.
* @throws IllegalArgumentException if one or more of the above
* conditions is violated.
*/
public void setToPage(int toPage) {
if (toPage <= 0 ||
(fromPage != 0 && toPage < fromPage) ||
toPage < minPage ||
toPage > maxPage) {
throw new IllegalArgumentException("Invalid value for attribute "+
"toPage");
}
this.toPage = toPage;
}
/**
* Determines whether two JobAttributes are equal to each other.
* <p>
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java