0001: /*
0002: * Copyright 1999-2006 Sun Microsystems, Inc. All Rights Reserved.
0003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
0004: *
0005: * This code is free software; you can redistribute it and/or modify it
0006: * under the terms of the GNU General Public License version 2 only, as
0007: * published by the Free Software Foundation. Sun designates this
0008: * particular file as subject to the "Classpath" exception as provided
0009: * by Sun in the LICENSE file that accompanied this code.
0010: *
0011: * This code is distributed in the hope that it will be useful, but WITHOUT
0012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0014: * version 2 for more details (a copy is included in the LICENSE file that
0015: * accompanied this code).
0016: *
0017: * You should have received a copy of the GNU General Public License version
0018: * 2 along with this work; if not, write to the Free Software Foundation,
0019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
0020: *
0021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
0022: * CA 95054 USA or visit www.sun.com if you need additional information or
0023: * have any questions.
0024: */
0025:
0026: package java.awt;
0027:
0028: /**
0029: * A set of attributes which control a print job.
0030: * <p>
0031: * Instances of this class control the number of copies, default selection,
0032: * destination, print dialog, file and printer names, page ranges, multiple
0033: * document handling (including collation), and multi-page imposition (such
0034: * as duplex) of every print job which uses the instance. Attribute names are
0035: * compliant with the Internet Printing Protocol (IPP) 1.1 where possible.
0036: * Attribute values are partially compliant where possible.
0037: * <p>
0038: * To use a method which takes an inner class type, pass a reference to
0039: * one of the constant fields of the inner class. Client code cannot create
0040: * new instances of the inner class types because none of those classes
0041: * has a public constructor. For example, to set the print dialog type to
0042: * the cross-platform, pure Java print dialog, use the following code:
0043: * <pre>
0044: * import java.awt.JobAttributes;
0045: *
0046: * public class PureJavaPrintDialogExample {
0047: * public void setPureJavaPrintDialog(JobAttributes jobAttributes) {
0048: * jobAttributes.setDialog(JobAttributes.DialogType.COMMON);
0049: * }
0050: * }
0051: * </pre>
0052: * <p>
0053: * Every IPP attribute which supports an <i>attributeName</i>-default value
0054: * has a corresponding <code>set<i>attributeName</i>ToDefault</code> method.
0055: * Default value fields are not provided.
0056: *
0057: * @version 1.17, 05/05/07
0058: * @author David Mendenhall
0059: * @since 1.3
0060: */
0061: public final class JobAttributes implements Cloneable {
0062: /**
0063: * A type-safe enumeration of possible default selection states.
0064: * @since 1.3
0065: */
0066: public static final class DefaultSelectionType extends
0067: AttributeValue {
0068: private static final int I_ALL = 0;
0069: private static final int I_RANGE = 1;
0070: private static final int I_SELECTION = 2;
0071:
0072: private static final String NAMES[] = { "all", "range",
0073: "selection" };
0074:
0075: /**
0076: * The <code>DefaultSelectionType</code> instance to use for
0077: * specifying that all pages of the job should be printed.
0078: */
0079: public static final DefaultSelectionType ALL = new DefaultSelectionType(
0080: I_ALL);
0081: /**
0082: * The <code>DefaultSelectionType</code> instance to use for
0083: * specifying that a range of pages of the job should be printed.
0084: */
0085: public static final DefaultSelectionType RANGE = new DefaultSelectionType(
0086: I_RANGE);
0087: /**
0088: * The <code>DefaultSelectionType</code> instance to use for
0089: * specifying that the current selection should be printed.
0090: */
0091: public static final DefaultSelectionType SELECTION = new DefaultSelectionType(
0092: I_SELECTION);
0093:
0094: private DefaultSelectionType(int type) {
0095: super (type, NAMES);
0096: }
0097: }
0098:
0099: /**
0100: * A type-safe enumeration of possible job destinations.
0101: * @since 1.3
0102: */
0103: public static final class DestinationType extends AttributeValue {
0104: private static final int I_FILE = 0;
0105: private static final int I_PRINTER = 1;
0106:
0107: private static final String NAMES[] = { "file", "printer" };
0108:
0109: /**
0110: * The <code>DestinationType</code> instance to use for
0111: * specifying print to file.
0112: */
0113: public static final DestinationType FILE = new DestinationType(
0114: I_FILE);
0115: /**
0116: * The <code>DestinationType</code> instance to use for
0117: * specifying print to printer.
0118: */
0119: public static final DestinationType PRINTER = new DestinationType(
0120: I_PRINTER);
0121:
0122: private DestinationType(int type) {
0123: super (type, NAMES);
0124: }
0125: }
0126:
0127: /**
0128: * A type-safe enumeration of possible dialogs to display to the user.
0129: * @since 1.3
0130: */
0131: public static final class DialogType extends AttributeValue {
0132: private static final int I_COMMON = 0;
0133: private static final int I_NATIVE = 1;
0134: private static final int I_NONE = 2;
0135:
0136: private static final String NAMES[] = { "common", "native",
0137: "none" };
0138:
0139: /**
0140: * The <code>DialogType</code> instance to use for
0141: * specifying the cross-platform, pure Java print dialog.
0142: */
0143: public static final DialogType COMMON = new DialogType(I_COMMON);
0144: /**
0145: * The <code>DialogType</code> instance to use for
0146: * specifying the platform's native print dialog.
0147: */
0148: public static final DialogType NATIVE = new DialogType(I_NATIVE);
0149: /**
0150: * The <code>DialogType</code> instance to use for
0151: * specifying no print dialog.
0152: */
0153: public static final DialogType NONE = new DialogType(I_NONE);
0154:
0155: private DialogType(int type) {
0156: super (type, NAMES);
0157: }
0158: }
0159:
0160: /**
0161: * A type-safe enumeration of possible multiple copy handling states.
0162: * It is used to control how the sheets of multiple copies of a single
0163: * document are collated.
0164: * @since 1.3
0165: */
0166: public static final class MultipleDocumentHandlingType extends
0167: AttributeValue {
0168: private static final int I_SEPARATE_DOCUMENTS_COLLATED_COPIES = 0;
0169: private static final int I_SEPARATE_DOCUMENTS_UNCOLLATED_COPIES = 1;
0170:
0171: private static final String NAMES[] = {
0172: "separate-documents-collated-copies",
0173: "separate-documents-uncollated-copies" };
0174:
0175: /**
0176: * The <code>MultipleDocumentHandlingType</code> instance to use for specifying
0177: * that the job should be divided into separate, collated copies.
0178: */
0179: public static final MultipleDocumentHandlingType SEPARATE_DOCUMENTS_COLLATED_COPIES = new MultipleDocumentHandlingType(
0180: I_SEPARATE_DOCUMENTS_COLLATED_COPIES);
0181: /**
0182: * The <code>MultipleDocumentHandlingType</code> instance to use for specifying
0183: * that the job should be divided into separate, uncollated copies.
0184: */
0185: public static final MultipleDocumentHandlingType SEPARATE_DOCUMENTS_UNCOLLATED_COPIES = new MultipleDocumentHandlingType(
0186: I_SEPARATE_DOCUMENTS_UNCOLLATED_COPIES);
0187:
0188: private MultipleDocumentHandlingType(int type) {
0189: super (type, NAMES);
0190: }
0191: }
0192:
0193: /**
0194: * A type-safe enumeration of possible multi-page impositions. These
0195: * impositions are in compliance with IPP 1.1.
0196: * @since 1.3
0197: */
0198: public static final class SidesType extends AttributeValue {
0199: private static final int I_ONE_SIDED = 0;
0200: private static final int I_TWO_SIDED_LONG_EDGE = 1;
0201: private static final int I_TWO_SIDED_SHORT_EDGE = 2;
0202:
0203: private static final String NAMES[] = { "one-sided",
0204: "two-sided-long-edge", "two-sided-short-edge" };
0205:
0206: /**
0207: * The <code>SidesType</code> instance to use for specifying that
0208: * consecutive job pages should be printed upon the same side of
0209: * consecutive media sheets.
0210: */
0211: public static final SidesType ONE_SIDED = new SidesType(
0212: I_ONE_SIDED);
0213: /**
0214: * The <code>SidesType</code> instance to use for specifying that
0215: * consecutive job pages should be printed upon front and back sides
0216: * of consecutive media sheets, such that the orientation of each pair
0217: * of pages on the medium would be correct for the reader as if for
0218: * binding on the long edge.
0219: */
0220: public static final SidesType TWO_SIDED_LONG_EDGE = new SidesType(
0221: I_TWO_SIDED_LONG_EDGE);
0222: /**
0223: * The <code>SidesType</code> instance to use for specifying that
0224: * consecutive job pages should be printed upon front and back sides
0225: * of consecutive media sheets, such that the orientation of each pair
0226: * of pages on the medium would be correct for the reader as if for
0227: * binding on the short edge.
0228: */
0229: public static final SidesType TWO_SIDED_SHORT_EDGE = new SidesType(
0230: I_TWO_SIDED_SHORT_EDGE);
0231:
0232: private SidesType(int type) {
0233: super (type, NAMES);
0234: }
0235: }
0236:
0237: private int copies;
0238: private DefaultSelectionType defaultSelection;
0239: private DestinationType destination;
0240: private DialogType dialog;
0241: private String fileName;
0242: private int fromPage;
0243: private int maxPage;
0244: private int minPage;
0245: private MultipleDocumentHandlingType multipleDocumentHandling;
0246: private int[][] pageRanges;
0247: private int prFirst;
0248: private int prLast;
0249: private String printer;
0250: private SidesType sides;
0251: private int toPage;
0252:
0253: /**
0254: * Constructs a <code>JobAttributes</code> instance with default
0255: * values for every attribute. The dialog defaults to
0256: * <code>DialogType.NATIVE</code>. Min page defaults to
0257: * <code>1</code>. Max page defaults to <code>Integer.MAX_VALUE</code>.
0258: * Destination defaults to <code>DestinationType.PRINTER</code>.
0259: * Selection defaults to <code>DefaultSelectionType.ALL</code>.
0260: * Number of copies defaults to <code>1</code>. Multiple document handling defaults
0261: * to <code>MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES</code>.
0262: * Sides defaults to <code>SidesType.ONE_SIDED</code>. File name defaults
0263: * to <code>null</code>.
0264: */
0265: public JobAttributes() {
0266: setCopiesToDefault();
0267: setDefaultSelection(DefaultSelectionType.ALL);
0268: setDestination(DestinationType.PRINTER);
0269: setDialog(DialogType.NATIVE);
0270: setMaxPage(Integer.MAX_VALUE);
0271: setMinPage(1);
0272: setMultipleDocumentHandlingToDefault();
0273: setSidesToDefault();
0274: }
0275:
0276: /**
0277: * Constructs a <code>JobAttributes</code> instance which is a copy
0278: * of the supplied <code>JobAttributes</code>.
0279: *
0280: * @param obj the <code>JobAttributes</code> to copy
0281: */
0282: public JobAttributes(JobAttributes obj) {
0283: set(obj);
0284: }
0285:
0286: /**
0287: * Constructs a <code>JobAttributes</code> instance with the
0288: * specified values for every attribute.
0289: *
0290: * @param copies an integer greater than 0
0291: * @param defaultSelection <code>DefaultSelectionType.ALL</code>,
0292: * <code>DefaultSelectionType.RANGE</code>, or
0293: * <code>DefaultSelectionType.SELECTION</code>
0294: * @param destination <code>DesintationType.FILE</code> or
0295: * <code>DesintationType.PRINTER</code>
0296: * @param dialog <code>DialogType.COMMON</code>,
0297: * <code>DialogType.NATIVE</code>, or
0298: * <code>DialogType.NONE</code>
0299: * @param fileName the possibly <code>null</code> file name
0300: * @param maxPage an integer greater than zero and greater than or equal
0301: * to <i>minPage</i>
0302: * @param minPage an integer greater than zero and less than or equal
0303: * to <i>maxPage</i>
0304: * @param multipleDocumentHandling
0305: * <code>MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES</code> or
0306: * <code>MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES</code>
0307: * @param pageRanges an array of integer arrays of two elements; an array
0308: * is interpreted as a range spanning all pages including and
0309: * between the specified pages; ranges must be in ascending
0310: * order and must not overlap; specified page numbers cannot be
0311: * less than <i>minPage</i> nor greater than <i>maxPage</i>;
0312: * for example:
0313: * <pre>
0314: * (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 },
0315: * new int[] { 15, 19 } }),
0316: * </pre>
0317: * specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19. Note that
0318: * (<code>new int[][] { new int[] { 1, 1 }, new int[] { 1, 2 } }</code>),
0319: * is an invalid set of page ranges because the two ranges
0320: * overlap
0321: * @param printer the possibly <code>null</code> printer name
0322: * @param sides <code>SidesType.ONE_SIDED</code>,
0323: * <code>SidesType.TWO_SIDED_LONG_EDGE</code>, or
0324: * <code>SidesType.TWO_SIDED_SHORT_EDGE</code>
0325: * @throws IllegalArgumentException if one or more of the above
0326: * conditions is violated
0327: */
0328: public JobAttributes(int copies,
0329: DefaultSelectionType defaultSelection,
0330: DestinationType destination, DialogType dialog,
0331: String fileName, int maxPage, int minPage,
0332: MultipleDocumentHandlingType multipleDocumentHandling,
0333: int[][] pageRanges, String printer, SidesType sides) {
0334: setCopies(copies);
0335: setDefaultSelection(defaultSelection);
0336: setDestination(destination);
0337: setDialog(dialog);
0338: setFileName(fileName);
0339: setMaxPage(maxPage);
0340: setMinPage(minPage);
0341: setMultipleDocumentHandling(multipleDocumentHandling);
0342: setPageRanges(pageRanges);
0343: setPrinter(printer);
0344: setSides(sides);
0345: }
0346:
0347: /**
0348: * Creates and returns a copy of this <code>JobAttributes</code>.
0349: *
0350: * @return the newly created copy; it is safe to cast this Object into
0351: * a <code>JobAttributes</code>
0352: */
0353: public Object clone() {
0354: try {
0355: return super .clone();
0356: } catch (CloneNotSupportedException e) {
0357: // Since we implement Cloneable, this should never happen
0358: throw new InternalError();
0359: }
0360: }
0361:
0362: /**
0363: * Sets all of the attributes of this <code>JobAttributes</code> to
0364: * the same values as the attributes of obj.
0365: *
0366: * @param obj the <code>JobAttributes</code> to copy
0367: */
0368: public void set(JobAttributes obj) {
0369: copies = obj.copies;
0370: defaultSelection = obj.defaultSelection;
0371: destination = obj.destination;
0372: dialog = obj.dialog;
0373: fileName = obj.fileName;
0374: fromPage = obj.fromPage;
0375: maxPage = obj.maxPage;
0376: minPage = obj.minPage;
0377: multipleDocumentHandling = obj.multipleDocumentHandling;
0378: // okay because we never modify the contents of pageRanges
0379: pageRanges = obj.pageRanges;
0380: prFirst = obj.prFirst;
0381: prLast = obj.prLast;
0382: printer = obj.printer;
0383: sides = obj.sides;
0384: toPage = obj.toPage;
0385: }
0386:
0387: /**
0388: * Returns the number of copies the application should render for jobs
0389: * using these attributes. This attribute is updated to the value chosen
0390: * by the user.
0391: *
0392: * @return an integer greater than 0.
0393: */
0394: public int getCopies() {
0395: return copies;
0396: }
0397:
0398: /**
0399: * Specifies the number of copies the application should render for jobs
0400: * using these attributes. Not specifying this attribute is equivalent to
0401: * specifying <code>1</code>.
0402: *
0403: * @param copies an integer greater than 0
0404: * @throws IllegalArgumentException if <code>copies</code> is less than
0405: * or equal to 0
0406: */
0407: public void setCopies(int copies) {
0408: if (copies <= 0) {
0409: throw new IllegalArgumentException(
0410: "Invalid value for attribute " + "copies");
0411: }
0412: this .copies = copies;
0413: }
0414:
0415: /**
0416: * Sets the number of copies the application should render for jobs using
0417: * these attributes to the default. The default number of copies is 1.
0418: */
0419: public void setCopiesToDefault() {
0420: setCopies(1);
0421: }
0422:
0423: /**
0424: * Specifies whether, for jobs using these attributes, the application
0425: * should print all pages, the range specified by the return value of
0426: * <code>getPageRanges</code>, or the current selection. This attribute
0427: * is updated to the value chosen by the user.
0428: *
0429: * @return DefaultSelectionType.ALL, DefaultSelectionType.RANGE, or
0430: * DefaultSelectionType.SELECTION
0431: */
0432: public DefaultSelectionType getDefaultSelection() {
0433: return defaultSelection;
0434: }
0435:
0436: /**
0437: * Specifies whether, for jobs using these attributes, the application
0438: * should print all pages, the range specified by the return value of
0439: * <code>getPageRanges</code>, or the current selection. Not specifying
0440: * this attribute is equivalent to specifying DefaultSelectionType.ALL.
0441: *
0442: * @param defaultSelection DefaultSelectionType.ALL,
0443: * DefaultSelectionType.RANGE, or DefaultSelectionType.SELECTION.
0444: * @throws IllegalArgumentException if defaultSelection is <code>null</code>
0445: */
0446: public void setDefaultSelection(
0447: DefaultSelectionType defaultSelection) {
0448: if (defaultSelection == null) {
0449: throw new IllegalArgumentException(
0450: "Invalid value for attribute " + "defaultSelection");
0451: }
0452: this .defaultSelection = defaultSelection;
0453: }
0454:
0455: /**
0456: * Specifies whether output will be to a printer or a file for jobs using
0457: * these attributes. This attribute is updated to the value chosen by the
0458: * user.
0459: *
0460: * @return DesintationType.FILE or DesintationType.PRINTER
0461: */
0462: public DestinationType getDestination() {
0463: return destination;
0464: }
0465:
0466: /**
0467: * Specifies whether output will be to a printer or a file for jobs using
0468: * these attributes. Not specifying this attribute is equivalent to
0469: * specifying DesintationType.PRINTER.
0470: *
0471: * @param destination DesintationType.FILE or DesintationType.PRINTER.
0472: * @throws IllegalArgumentException if destination is null.
0473: */
0474: public void setDestination(DestinationType destination) {
0475: if (destination == null) {
0476: throw new IllegalArgumentException(
0477: "Invalid value for attribute " + "destination");
0478: }
0479: this .destination = destination;
0480: }
0481:
0482: /**
0483: * Returns whether, for jobs using these attributes, the user should see
0484: * a print dialog in which to modify the print settings, and which type of
0485: * print dialog should be displayed. DialogType.COMMON denotes a cross-
0486: * platform, pure Java print dialog. DialogType.NATIVE denotes the
0487: * platform's native print dialog. If a platform does not support a native
0488: * print dialog, the pure Java print dialog is displayed instead.
0489: * DialogType.NONE specifies no print dialog (i.e., background printing).
0490: * This attribute cannot be modified by, and is not subject to any
0491: * limitations of, the implementation or the target printer.
0492: *
0493: * @return <code>DialogType.COMMON</code>, <code>DialogType.NATIVE</code>, or
0494: * <code>DialogType.NONE</code>
0495: */
0496: public DialogType getDialog() {
0497: return dialog;
0498: }
0499:
0500: /**
0501: * Specifies whether, for jobs using these attributes, the user should see
0502: * a print dialog in which to modify the print settings, and which type of
0503: * print dialog should be displayed. DialogType.COMMON denotes a cross-
0504: * platform, pure Java print dialog. DialogType.NATIVE denotes the
0505: * platform's native print dialog. If a platform does not support a native
0506: * print dialog, the pure Java print dialog is displayed instead.
0507: * DialogType.NONE specifies no print dialog (i.e., background printing).
0508: * Not specifying this attribute is equivalent to specifying
0509: * DialogType.NATIVE.
0510: *
0511: * @param dialog DialogType.COMMON, DialogType.NATIVE, or
0512: * DialogType.NONE.
0513: * @throws IllegalArgumentException if dialog is null.
0514: */
0515: public void setDialog(DialogType dialog) {
0516: if (dialog == null) {
0517: throw new IllegalArgumentException(
0518: "Invalid value for attribute " + "dialog");
0519: }
0520: this .dialog = dialog;
0521: }
0522:
0523: /**
0524: * Specifies the file name for the output file for jobs using these
0525: * attributes. This attribute is updated to the value chosen by the user.
0526: *
0527: * @return the possibly <code>null</code> file name
0528: */
0529: public String getFileName() {
0530: return fileName;
0531: }
0532:
0533: /**
0534: * Specifies the file name for the output file for jobs using these
0535: * attributes. Default is platform-dependent and implementation-defined.
0536: *
0537: * @param fileName the possibly null file name.
0538: */
0539: public void setFileName(String fileName) {
0540: this .fileName = fileName;
0541: }
0542:
0543: /**
0544: * Returns, for jobs using these attributes, the first page to be
0545: * printed, if a range of pages is to be printed. This attribute is
0546: * updated to the value chosen by the user. An application should ignore
0547: * this attribute on output, unless the return value of the <code>
0548: * getDefaultSelection</code> method is DefaultSelectionType.RANGE. An
0549: * application should honor the return value of <code>getPageRanges</code>
0550: * over the return value of this method, if possible.
0551: *
0552: * @return an integer greater than zero and less than or equal to
0553: * <i>toPage</i> and greater than or equal to <i>minPage</i> and
0554: * less than or equal to <i>maxPage</i>.
0555: */
0556: public int getFromPage() {
0557: if (fromPage != 0) {
0558: return fromPage;
0559: } else if (toPage != 0) {
0560: return getMinPage();
0561: } else if (pageRanges != null) {
0562: return prFirst;
0563: } else {
0564: return getMinPage();
0565: }
0566: }
0567:
0568: /**
0569: * Specifies, for jobs using these attributes, the first page to be
0570: * printed, if a range of pages is to be printed. If this attribute is not
0571: * specified, then the values from the pageRanges attribute are used. If
0572: * pageRanges and either or both of fromPage and toPage are specified,
0573: * pageRanges takes precedence. Specifying none of pageRanges, fromPage,
0574: * or toPage is equivalent to calling
0575: * setPageRanges(new int[][] { new int[] { <i>minPage</i> } });
0576: *
0577: * @param fromPage an integer greater than zero and less than or equal to
0578: * <i>toPage</i> and greater than or equal to <i>minPage</i> and
0579: * less than or equal to <i>maxPage</i>.
0580: * @throws IllegalArgumentException if one or more of the above
0581: * conditions is violated.
0582: */
0583: public void setFromPage(int fromPage) {
0584: if (fromPage <= 0 || (toPage != 0 && fromPage > toPage)
0585: || fromPage < minPage || fromPage > maxPage) {
0586: throw new IllegalArgumentException(
0587: "Invalid value for attribute " + "fromPage");
0588: }
0589: this .fromPage = fromPage;
0590: }
0591:
0592: /**
0593: * Specifies the maximum value the user can specify as the last page to
0594: * be printed for jobs using these attributes. This attribute cannot be
0595: * modified by, and is not subject to any limitations of, the
0596: * implementation or the target printer.
0597: *
0598: * @return an integer greater than zero and greater than or equal
0599: * to <i>minPage</i>.
0600: */
0601: public int getMaxPage() {
0602: return maxPage;
0603: }
0604:
0605: /**
0606: * Specifies the maximum value the user can specify as the last page to
0607: * be printed for jobs using these attributes. Not specifying this
0608: * attribute is equivalent to specifying <code>Integer.MAX_VALUE</code>.
0609: *
0610: * @param maxPage an integer greater than zero and greater than or equal
0611: * to <i>minPage</i>
0612: * @throws IllegalArgumentException if one or more of the above
0613: * conditions is violated
0614: */
0615: public void setMaxPage(int maxPage) {
0616: if (maxPage <= 0 || maxPage < minPage) {
0617: throw new IllegalArgumentException(
0618: "Invalid value for attribute " + "maxPage");
0619: }
0620: this .maxPage = maxPage;
0621: }
0622:
0623: /**
0624: * Specifies the minimum value the user can specify as the first page to
0625: * be printed for jobs using these attributes. This attribute cannot be
0626: * modified by, and is not subject to any limitations of, the
0627: * implementation or the target printer.
0628: *
0629: * @return an integer greater than zero and less than or equal
0630: * to <i>maxPage</i>.
0631: */
0632: public int getMinPage() {
0633: return minPage;
0634: }
0635:
0636: /**
0637: * Specifies the minimum value the user can specify as the first page to
0638: * be printed for jobs using these attributes. Not specifying this
0639: * attribute is equivalent to specifying <code>1</code>.
0640: *
0641: * @param minPage an integer greater than zero and less than or equal
0642: * to <i>maxPage</i>.
0643: * @throws IllegalArgumentException if one or more of the above
0644: * conditions is violated.
0645: */
0646: public void setMinPage(int minPage) {
0647: if (minPage <= 0 || minPage > maxPage) {
0648: throw new IllegalArgumentException(
0649: "Invalid value for attribute " + "minPage");
0650: }
0651: this .minPage = minPage;
0652: }
0653:
0654: /**
0655: * Specifies the handling of multiple copies, including collation, for
0656: * jobs using these attributes. This attribute is updated to the value
0657: * chosen by the user.
0658: *
0659: * @return
0660: * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES or
0661: * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES.
0662: */
0663: public MultipleDocumentHandlingType getMultipleDocumentHandling() {
0664: return multipleDocumentHandling;
0665: }
0666:
0667: /**
0668: * Specifies the handling of multiple copies, including collation, for
0669: * jobs using these attributes. Not specifying this attribute is equivalent
0670: * to specifying
0671: * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES.
0672: *
0673: * @param multipleDocumentHandling
0674: * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES or
0675: * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES.
0676: * @throws IllegalArgumentException if multipleDocumentHandling is null.
0677: */
0678: public void setMultipleDocumentHandling(
0679: MultipleDocumentHandlingType multipleDocumentHandling) {
0680: if (multipleDocumentHandling == null) {
0681: throw new IllegalArgumentException(
0682: "Invalid value for attribute "
0683: + "multipleDocumentHandling");
0684: }
0685: this .multipleDocumentHandling = multipleDocumentHandling;
0686: }
0687:
0688: /**
0689: * Sets the handling of multiple copies, including collation, for jobs
0690: * using these attributes to the default. The default handling is
0691: * MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES.
0692: */
0693: public void setMultipleDocumentHandlingToDefault() {
0694: setMultipleDocumentHandling(MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES);
0695: }
0696:
0697: /**
0698: * Specifies, for jobs using these attributes, the ranges of pages to be
0699: * printed, if a range of pages is to be printed. All range numbers are
0700: * inclusive. This attribute is updated to the value chosen by the user.
0701: * An application should ignore this attribute on output, unless the
0702: * return value of the <code>getDefaultSelection</code> method is
0703: * DefaultSelectionType.RANGE.
0704: *
0705: * @return an array of integer arrays of 2 elements. An array
0706: * is interpreted as a range spanning all pages including and
0707: * between the specified pages. Ranges must be in ascending
0708: * order and must not overlap. Specified page numbers cannot be
0709: * less than <i>minPage</i> nor greater than <i>maxPage</i>.
0710: * For example:
0711: * (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 },
0712: * new int[] { 15, 19 } }),
0713: * specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19.
0714: */
0715: public int[][] getPageRanges() {
0716: if (pageRanges != null) {
0717: // Return a copy because otherwise client code could circumvent the
0718: // the checks made in setPageRanges by modifying the returned
0719: // array.
0720: int[][] copy = new int[pageRanges.length][2];
0721: for (int i = 0; i < pageRanges.length; i++) {
0722: copy[i][0] = pageRanges[i][0];
0723: copy[i][1] = pageRanges[i][1];
0724: }
0725: return copy;
0726: } else if (fromPage != 0 || toPage != 0) {
0727: int fromPage = getFromPage();
0728: int toPage = getToPage();
0729: return new int[][] { new int[] { fromPage, toPage } };
0730: } else {
0731: int minPage = getMinPage();
0732: return new int[][] { new int[] { minPage, minPage } };
0733: }
0734: }
0735:
0736: /**
0737: * Specifies, for jobs using these attributes, the ranges of pages to be
0738: * printed, if a range of pages is to be printed. All range numbers are
0739: * inclusive. If this attribute is not specified, then the values from the
0740: * fromPage and toPages attributes are used. If pageRanges and either or
0741: * both of fromPage and toPage are specified, pageRanges takes precedence.
0742: * Specifying none of pageRanges, fromPage, or toPage is equivalent to
0743: * calling setPageRanges(new int[][] { new int[] { <i>minPage</i>,
0744: * <i>minPage</i> } });
0745: *
0746: * @param pageRanges an array of integer arrays of 2 elements. An array
0747: * is interpreted as a range spanning all pages including and
0748: * between the specified pages. Ranges must be in ascending
0749: * order and must not overlap. Specified page numbers cannot be
0750: * less than <i>minPage</i> nor greater than <i>maxPage</i>.
0751: * For example:
0752: * (new int[][] { new int[] { 1, 3 }, new int[] { 5, 5 },
0753: * new int[] { 15, 19 } }),
0754: * specifies pages 1, 2, 3, 5, 15, 16, 17, 18, and 19. Note that
0755: * (new int[][] { new int[] { 1, 1 }, new int[] { 1, 2 } }),
0756: * is an invalid set of page ranges because the two ranges
0757: * overlap.
0758: * @throws IllegalArgumentException if one or more of the above
0759: * conditions is violated.
0760: */
0761: public void setPageRanges(int[][] pageRanges) {
0762: String xcp = "Invalid value for attribute pageRanges";
0763: int first = 0;
0764: int last = 0;
0765:
0766: if (pageRanges == null) {
0767: throw new IllegalArgumentException(xcp);
0768: }
0769:
0770: for (int i = 0; i < pageRanges.length; i++) {
0771: if (pageRanges[i] == null || pageRanges[i].length != 2
0772: || pageRanges[i][0] <= last
0773: || pageRanges[i][1] < pageRanges[i][0]) {
0774: throw new IllegalArgumentException(xcp);
0775: }
0776: last = pageRanges[i][1];
0777: if (first == 0) {
0778: first = pageRanges[i][0];
0779: }
0780: }
0781:
0782: if (first < minPage || last > maxPage) {
0783: throw new IllegalArgumentException(xcp);
0784: }
0785:
0786: // Store a copy because otherwise client code could circumvent the
0787: // the checks made above by holding a reference to the array and
0788: // modifying it after calling setPageRanges.
0789: int[][] copy = new int[pageRanges.length][2];
0790: for (int i = 0; i < pageRanges.length; i++) {
0791: copy[i][0] = pageRanges[i][0];
0792: copy[i][1] = pageRanges[i][1];
0793: }
0794: this .pageRanges = copy;
0795: this .prFirst = first;
0796: this .prLast = last;
0797: }
0798:
0799: /**
0800: * Returns the destination printer for jobs using these attributes. This
0801: * attribute is updated to the value chosen by the user.
0802: *
0803: * @return the possibly null printer name.
0804: */
0805: public String getPrinter() {
0806: return printer;
0807: }
0808:
0809: /**
0810: * Specifies the destination printer for jobs using these attributes.
0811: * Default is platform-dependent and implementation-defined.
0812: *
0813: * @param printer the possibly null printer name.
0814: */
0815: public void setPrinter(String printer) {
0816: this .printer = printer;
0817: }
0818:
0819: /**
0820: * Returns how consecutive pages should be imposed upon the sides of the
0821: * print medium for jobs using these attributes. SidesType.ONE_SIDED
0822: * imposes each consecutive page upon the same side of consecutive media
0823: * sheets. This imposition is sometimes called <i>simplex</i>.
0824: * SidesType.TWO_SIDED_LONG_EDGE imposes each consecutive pair of pages
0825: * upon front and back sides of consecutive media sheets, such that the
0826: * orientation of each pair of pages on the medium would be correct for
0827: * the reader as if for binding on the long edge. This imposition is
0828: * sometimes called <i>duplex</i>. SidesType.TWO_SIDED_SHORT_EDGE imposes
0829: * each consecutive pair of pages upon front and back sides of consecutive
0830: * media sheets, such that the orientation of each pair of pages on the
0831: * medium would be correct for the reader as if for binding on the short
0832: * edge. This imposition is sometimes called <i>tumble</i>. This attribute
0833: * is updated to the value chosen by the user.
0834: *
0835: * @return SidesType.ONE_SIDED, SidesType.TWO_SIDED_LONG_EDGE, or
0836: * SidesType.TWO_SIDED_SHORT_EDGE.
0837: */
0838: public SidesType getSides() {
0839: return sides;
0840: }
0841:
0842: /**
0843: * Specifies how consecutive pages should be imposed upon the sides of the
0844: * print medium for jobs using these attributes. SidesType.ONE_SIDED
0845: * imposes each consecutive page upon the same side of consecutive media
0846: * sheets. This imposition is sometimes called <i>simplex</i>.
0847: * SidesType.TWO_SIDED_LONG_EDGE imposes each consecutive pair of pages
0848: * upon front and back sides of consecutive media sheets, such that the
0849: * orientation of each pair of pages on the medium would be correct for
0850: * the reader as if for binding on the long edge. This imposition is
0851: * sometimes called <i>duplex</i>. SidesType.TWO_SIDED_SHORT_EDGE imposes
0852: * each consecutive pair of pages upon front and back sides of consecutive
0853: * media sheets, such that the orientation of each pair of pages on the
0854: * medium would be correct for the reader as if for binding on the short
0855: * edge. This imposition is sometimes called <i>tumble</i>. Not specifying
0856: * this attribute is equivalent to specifying SidesType.ONE_SIDED.
0857: *
0858: * @param sides SidesType.ONE_SIDED, SidesType.TWO_SIDED_LONG_EDGE, or
0859: * SidesType.TWO_SIDED_SHORT_EDGE.
0860: * @throws IllegalArgumentException if sides is null.
0861: */
0862: public void setSides(SidesType sides) {
0863: if (sides == null) {
0864: throw new IllegalArgumentException(
0865: "Invalid value for attribute " + "sides");
0866: }
0867: this .sides = sides;
0868: }
0869:
0870: /**
0871: * Sets how consecutive pages should be imposed upon the sides of the
0872: * print medium for jobs using these attributes to the default. The
0873: * default imposition is SidesType.ONE_SIDED.
0874: */
0875: public void setSidesToDefault() {
0876: setSides(SidesType.ONE_SIDED);
0877: }
0878:
0879: /**
0880: * Returns, for jobs using these attributes, the last page (inclusive)
0881: * to be printed, if a range of pages is to be printed. This attribute is
0882: * updated to the value chosen by the user. An application should ignore
0883: * this attribute on output, unless the return value of the <code>
0884: * getDefaultSelection</code> method is DefaultSelectionType.RANGE. An
0885: * application should honor the return value of <code>getPageRanges</code>
0886: * over the return value of this method, if possible.
0887: *
0888: * @return an integer greater than zero and greater than or equal
0889: * to <i>toPage</i> and greater than or equal to <i>minPage</i>
0890: * and less than or equal to <i>maxPage</i>.
0891: */
0892: public int getToPage() {
0893: if (toPage != 0) {
0894: return toPage;
0895: } else if (fromPage != 0) {
0896: return fromPage;
0897: } else if (pageRanges != null) {
0898: return prLast;
0899: } else {
0900: return getMinPage();
0901: }
0902: }
0903:
0904: /**
0905: * Specifies, for jobs using these attributes, the last page (inclusive)
0906: * to be printed, if a range of pages is to be printed.
0907: * If this attribute is not specified, then the values from the pageRanges
0908: * attribute are used. If pageRanges and either or both of fromPage and
0909: * toPage are specified, pageRanges takes precedence. Specifying none of
0910: * pageRanges, fromPage, or toPage is equivalent to calling
0911: * setPageRanges(new int[][] { new int[] { <i>minPage</i> } });
0912: *
0913: * @param toPage an integer greater than zero and greater than or equal
0914: * to <i>fromPage</i> and greater than or equal to <i>minPage</i>
0915: * and less than or equal to <i>maxPage</i>.
0916: * @throws IllegalArgumentException if one or more of the above
0917: * conditions is violated.
0918: */
0919: public void setToPage(int toPage) {
0920: if (toPage <= 0 || (fromPage != 0 && toPage < fromPage)
0921: || toPage < minPage || toPage > maxPage) {
0922: throw new IllegalArgumentException(
0923: "Invalid value for attribute " + "toPage");
0924: }
0925: this .toPage = toPage;
0926: }
0927:
0928: /**
0929: * Determines whether two JobAttributes are equal to each other.
0930: * <p>
0931: * Two JobAttributes are equal if and only if each of their attributes are
0932: * equal. Attributes of enumeration type are equal if and only if the
0933: * fields refer to the same unique enumeration object. A set of page
0934: * ranges is equal if and only if the sets are of equal length, each range
0935: * enumerates the same pages, and the ranges are in the same order.
0936: *
0937: * @param obj the object whose equality will be checked.
0938: * @return whether obj is equal to this JobAttribute according to the
0939: * above criteria.
0940: */
0941: public boolean equals(Object obj) {
0942: if (!(obj instanceof JobAttributes)) {
0943: return false;
0944: }
0945: JobAttributes rhs = (JobAttributes) obj;
0946:
0947: if (fileName == null) {
0948: if (rhs.fileName != null) {
0949: return false;
0950: }
0951: } else {
0952: if (!fileName.equals(rhs.fileName)) {
0953: return false;
0954: }
0955: }
0956:
0957: if (pageRanges == null) {
0958: if (rhs.pageRanges != null) {
0959: return false;
0960: }
0961: } else {
0962: if (rhs.pageRanges == null
0963: || pageRanges.length != rhs.pageRanges.length) {
0964: return false;
0965: }
0966: for (int i = 0; i < pageRanges.length; i++) {
0967: if (pageRanges[i][0] != rhs.pageRanges[i][0]
0968: || pageRanges[i][1] != rhs.pageRanges[i][1]) {
0969: return false;
0970: }
0971: }
0972: }
0973:
0974: if (printer == null) {
0975: if (rhs.printer != null) {
0976: return false;
0977: }
0978: } else {
0979: if (!printer.equals(rhs.printer)) {
0980: return false;
0981: }
0982: }
0983:
0984: return (copies == rhs.copies
0985: && defaultSelection == rhs.defaultSelection
0986: && destination == rhs.destination
0987: && dialog == rhs.dialog
0988: && fromPage == rhs.fromPage
0989: && maxPage == rhs.maxPage
0990: && minPage == rhs.minPage
0991: && multipleDocumentHandling == rhs.multipleDocumentHandling
0992: && prFirst == rhs.prFirst && prLast == rhs.prLast
0993: && sides == rhs.sides && toPage == rhs.toPage);
0994: }
0995:
0996: /**
0997: * Returns a hash code value for this JobAttributes.
0998: *
0999: * @return the hash code.
1000: */
1001: public int hashCode() {
1002: int rest = ((copies + fromPage + maxPage + minPage + prFirst
1003: + prLast + toPage) * 31) << 21;
1004: if (pageRanges != null) {
1005: int sum = 0;
1006: for (int i = 0; i < pageRanges.length; i++) {
1007: sum += pageRanges[i][0] + pageRanges[i][1];
1008: }
1009: rest ^= (sum * 31) << 11;
1010: }
1011: if (fileName != null) {
1012: rest ^= fileName.hashCode();
1013: }
1014: if (printer != null) {
1015: rest ^= printer.hashCode();
1016: }
1017: return (defaultSelection.hashCode() << 6
1018: ^ destination.hashCode() << 5 ^ dialog.hashCode() << 3
1019: ^ multipleDocumentHandling.hashCode() << 2
1020: ^ sides.hashCode() ^ rest);
1021: }
1022:
1023: /**
1024: * Returns a string representation of this JobAttributes.
1025: *
1026: * @return the string representation.
1027: */
1028: public String toString() {
1029: int[][] pageRanges = getPageRanges();
1030: String prStr = "[";
1031: boolean first = true;
1032: for (int i = 0; i < pageRanges.length; i++) {
1033: if (first) {
1034: first = false;
1035: } else {
1036: prStr += ",";
1037: }
1038: prStr += pageRanges[i][0] + ":" + pageRanges[i][1];
1039: }
1040: prStr += "]";
1041:
1042: return "copies=" + getCopies() + ",defaultSelection="
1043: + getDefaultSelection() + ",destination="
1044: + getDestination() + ",dialog=" + getDialog()
1045: + ",fileName=" + getFileName() + ",fromPage="
1046: + getFromPage() + ",maxPage=" + getMaxPage()
1047: + ",minPage=" + getMinPage()
1048: + ",multiple-document-handling="
1049: + getMultipleDocumentHandling() + ",page-ranges="
1050: + prStr + ",printer=" + getPrinter() + ",sides="
1051: + getSides() + ",toPage=" + getToPage();
1052: }
1053: }
|
