You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
462 lines
18 KiB
462 lines
18 KiB
/*
|
|
* Copyright (c) 2000, 2004, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
package javax.print.attribute.standard;
|
|
|
|
import javax.print.attribute.EnumSyntax;
|
|
import javax.print.attribute.Attribute;
|
|
|
|
/**
|
|
* Class JobStateReason is a printing attribute class, an enumeration, that
|
|
* provides additional information about the job's current state, i.e.,
|
|
* information that augments the value of the job's {@link JobState JobState}
|
|
* attribute. Class JobStateReason defines standard job state reason values. A
|
|
* Print Service implementation only needs to report those job state
|
|
* reasons which are appropriate for the particular implementation; it does not
|
|
* have to report every defined job state reason.
|
|
* <P>
|
|
* Instances of JobStateReason do not appear in a Print Job's attribute set
|
|
* directly. Rather, a {@link JobStateReasons JobStateReasons} attribute appears
|
|
* in the Print Job's attribute set. The {@link JobStateReasons JobStateReasons}
|
|
* attribute contains zero, one, or more than one JobStateReason objects which
|
|
* pertain to the Print Job's status. The printer adds a JobStateReason object
|
|
* to the Print Job's {@link JobStateReasons JobStateReasons} attribute when the
|
|
* corresponding condition becomes true of the Print Job, and the printer
|
|
* removes the JobStateReason object again when the corresponding condition
|
|
* becomes false, regardless of whether the Print Job's overall {@link JobState
|
|
* JobState} also changed.
|
|
* <P>
|
|
* <B>IPP Compatibility:</B> The category name returned by
|
|
* <CODE>getName()</CODE> is the IPP attribute name. The enumeration's
|
|
* integer value is the IPP enum value. The <code>toString()</code> method
|
|
* returns the IPP string representation of the attribute value.
|
|
* <P>
|
|
*
|
|
* @author Alan Kaminsky
|
|
*/
|
|
public class JobStateReason extends EnumSyntax implements Attribute {
|
|
|
|
private static final long serialVersionUID = -8765894420449009168L;
|
|
|
|
/**
|
|
* The printer has created the Print Job, but the printer has not finished
|
|
* accessing or accepting all the print data yet.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_INCOMING = new JobStateReason(0);
|
|
|
|
/**
|
|
* The printer has created the Print Job, but the printer is expecting
|
|
* additional print data before it can move the job into the PROCESSING
|
|
* state. If a printer starts processing before it has received all data,
|
|
* the printer removes the JOB_DATA_INSUFFICIENT reason, but the
|
|
* JOB_INCOMING reason remains. If a printer starts processing after it
|
|
* has received all data, the printer removes the JOB_DATA_INSUFFICIENT
|
|
* and JOB_INCOMING reasons at the same time.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_DATA_INSUFFICIENT = new JobStateReason(1);
|
|
|
|
/**
|
|
* The Printer could not access one or more documents passed by reference
|
|
* (i.e., the print data representation object is a URL). This reason is
|
|
* intended to cover any file access problem,including file does not exist
|
|
* and access denied because of an access control problem. Whether the
|
|
* printer aborts the job and moves the job to the ABORTED job state or
|
|
* prints all documents that are accessible and moves the job to the
|
|
* COMPLETED job state and adds the COMPLETED_WITH_ERRORS reason to the
|
|
* job's {@link JobStateReasons JobStateReasons} attribute depends on
|
|
* implementation and/or site policy. This value should be supported if
|
|
* the printer supports doc flavors with URL print data representation
|
|
* objects.
|
|
*/
|
|
public static final JobStateReason
|
|
DOCUMENT_ACCESS_ERROR = new JobStateReason(2);
|
|
|
|
/**
|
|
* The job was not completely submitted for some unforeseen reason.
|
|
* Possibilities include (1) the printer has crashed before the job was
|
|
* fully submitted by the client, (2) the printer or the document transfer
|
|
* method has crashed in some non-recoverable way before the document data
|
|
* was entirely transferred to the printer, (3) the client crashed before
|
|
* the job was fully submitted.
|
|
*/
|
|
public static final JobStateReason
|
|
SUBMISSION_INTERRUPTED = new JobStateReason(3);
|
|
|
|
/**
|
|
* The printer is transmitting the job to the output device.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_OUTGOING = new JobStateReason(4);
|
|
|
|
/**
|
|
* The value of the job's {@link JobHoldUntil JobHoldUntil} attribute was
|
|
* specified with a date-time that is still in the future. The job must
|
|
* not be a candidate for processing until this reason is removed and
|
|
* there are
|
|
* no other reasons to hold the job. This value should be supported if the
|
|
* {@link JobHoldUntil JobHoldUntil} job template attribute is supported.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_HOLD_UNTIL_SPECIFIED = new JobStateReason(5);
|
|
|
|
/**
|
|
* At least one of the resources needed by the job, such as media, fonts,
|
|
* resource objects, etc., is not ready on any of the physical printers
|
|
* for which the job is a candidate. This condition may be detected
|
|
* when the job is accepted, or subsequently while the job is pending
|
|
* or processing, depending on implementation.
|
|
* The job may remain in its current state or
|
|
* be moved to the PENDING_HELD state, depending on implementation and/or
|
|
* job scheduling policy.
|
|
*/
|
|
public static final JobStateReason
|
|
RESOURCES_ARE_NOT_READY = new JobStateReason(6);
|
|
|
|
/**
|
|
* The value of the printer's {@link PrinterStateReasons
|
|
* PrinterStateReasons} attribute contains a {@link PrinterStateReason
|
|
* PrinterStateReason} value of STOPPED_PARTLY.
|
|
*/
|
|
public static final JobStateReason
|
|
PRINTER_STOPPED_PARTLY = new JobStateReason(7);
|
|
|
|
/**
|
|
* The value of the printer's {@link PrinterState PrinterState} attribute
|
|
* ia STOPPED.
|
|
*/
|
|
public static final JobStateReason
|
|
PRINTER_STOPPED = new JobStateReason(8);
|
|
|
|
/**
|
|
* The job is in the PROCESSING state, but more specifically, the printer
|
|
* ia interpreting the document data.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_INTERPRETING = new JobStateReason(9);
|
|
|
|
/**
|
|
* The job is in the PROCESSING state, but more specifically, the printer
|
|
* has queued the document data.
|
|
*/
|
|
public static final JobStateReason JOB_QUEUED = new JobStateReason(10);
|
|
|
|
/**
|
|
* The job is in the PROCESSING state, but more specifically, the printer
|
|
* is interpreting document data and producing another electronic
|
|
* representation.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_TRANSFORMING = new JobStateReason(11);
|
|
|
|
/**
|
|
* The job is in the PENDING_HELD, PENDING, or PROCESSING state, but more
|
|
* specifically, the printer has completed enough processing of the document
|
|
* to be able to start marking and the job is waiting for the marker.
|
|
* Systems that require human intervention to release jobs put the job into
|
|
* the PENDING_HELD job state. Systems that automatically select a job to
|
|
* use the marker put the job into the PENDING job state or keep the job
|
|
* in the PROCESSING job state while waiting for the marker, depending on
|
|
* implementation. All implementations put the job into (or back into) the
|
|
* PROCESSING state when marking does begin.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_QUEUED_FOR_MARKER = new JobStateReason(12);
|
|
|
|
/**
|
|
* The output device is marking media. This value is useful for printers
|
|
* which spend a great deal of time processing (1) when no marking is
|
|
* happening and then want to show that marking is now happening or (2) when
|
|
* the job is in the process of being canceled or aborted while the job
|
|
* remains in the PROCESSING state, but the marking has not yet stopped so
|
|
* that impression or sheet counts are still increasing for the job.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_PRINTING = new JobStateReason(13);
|
|
|
|
/**
|
|
* The job was canceled by the owner of the job, i.e., by a user whose
|
|
* authenticated identity is the same as the value of the originating user
|
|
* that created the Print Job, or by some other authorized end-user, such as
|
|
* a member of the job owner's security group. This value should be
|
|
* supported.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_CANCELED_BY_USER = new JobStateReason(14);
|
|
|
|
/**
|
|
* The job was canceled by the operator, i.e., by a user who has been
|
|
* authenticated as having operator privileges (whether local or remote). If
|
|
* the security policy is to allow anyone to cancel anyone's job, then this
|
|
* value may be used when the job is canceled by someone other than the
|
|
* owner of the job. For such a security policy, in effect, everyone is an
|
|
* operator as far as canceling jobs is concerned. This value should be
|
|
* supported if the implementation permits canceling by someone other than
|
|
* the owner of the job.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_CANCELED_BY_OPERATOR = new JobStateReason(15);
|
|
|
|
/**
|
|
* The job was canceled by an unidentified local user, i.e., a user at a
|
|
* console at the device. This value should be supported if the
|
|
* implementation supports canceling jobs at the console.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_CANCELED_AT_DEVICE = new JobStateReason(16);
|
|
|
|
/**
|
|
* The job was aborted by the system. Either the job (1) is in the process
|
|
* of being aborted, (2) has been aborted by the system and placed in the
|
|
* ABORTED state, or (3) has been aborted by the system and placed in the
|
|
* PENDING_HELD state, so that a user or operator can manually try the job
|
|
* again. This value should be supported.
|
|
*/
|
|
public static final JobStateReason
|
|
ABORTED_BY_SYSTEM = new JobStateReason(17);
|
|
|
|
/**
|
|
* The job was aborted by the system because the printer determined while
|
|
* attempting to decompress the document's data that the compression is
|
|
* actually not among those supported by the printer. This value must be
|
|
* supported, since {@link Compression Compression} is a required doc
|
|
* description attribute.
|
|
*/
|
|
public static final JobStateReason
|
|
UNSUPPORTED_COMPRESSION = new JobStateReason(18);
|
|
|
|
/**
|
|
* The job was aborted by the system because the printer encountered an
|
|
* error in the document data while decompressing it. If the printer posts
|
|
* this reason, the document data has already passed any tests that would
|
|
* have led to the UNSUPPORTED_COMPRESSION job state reason.
|
|
*/
|
|
public static final JobStateReason
|
|
COMPRESSION_ERROR = new JobStateReason(19);
|
|
|
|
/**
|
|
* The job was aborted by the system because the document data's document
|
|
* format (doc flavor) is not among those supported by the printer. If the
|
|
* client specifies a doc flavor with a MIME type of
|
|
* <CODE>"application/octet-stream"</CODE>, the printer may abort the job if
|
|
* the printer cannot determine the document data's actual format through
|
|
* auto-sensing (even if the printer supports the document format if
|
|
* specified explicitly). This value must be supported, since a doc flavor
|
|
* is required to be specified for each doc.
|
|
*/
|
|
public static final JobStateReason
|
|
UNSUPPORTED_DOCUMENT_FORMAT = new JobStateReason(20);
|
|
|
|
/**
|
|
* The job was aborted by the system because the printer encountered an
|
|
* error in the document data while processing it. If the printer posts this
|
|
* reason, the document data has already passed any tests that would have
|
|
* led to the UNSUPPORTED_DOCUMENT_FORMAT job state reason.
|
|
*/
|
|
public static final JobStateReason
|
|
DOCUMENT_FORMAT_ERROR = new JobStateReason(21);
|
|
|
|
/**
|
|
* The requester has canceled the job or the printer has aborted the job,
|
|
* but the printer is still performing some actions on the job until a
|
|
* specified stop point occurs or job termination/cleanup is completed.
|
|
* <P>
|
|
* If the implementation requires some measurable time to cancel the job in
|
|
* the PROCESSING or PROCESSING_STOPPED job states, the printer must use
|
|
* this reason to indicate that the printer is still performing some actions
|
|
* on the job while the job remains in the PROCESSING or PROCESSING_STOPPED
|
|
* state. After all the job's job description attributes have stopped
|
|
* incrementing, the printer moves the job from the PROCESSING state to the
|
|
* CANCELED or ABORTED job states.
|
|
*/
|
|
public static final JobStateReason
|
|
PROCESSING_TO_STOP_POINT = new JobStateReason(22);
|
|
|
|
/**
|
|
* The printer is off-line and accepting no jobs. All PENDING jobs are put
|
|
* into the PENDING_HELD state. This situation could be true if the
|
|
* service's or document transform's input is impaired or broken.
|
|
*/
|
|
public static final JobStateReason
|
|
SERVICE_OFF_LINE = new JobStateReason(23);
|
|
|
|
/**
|
|
* The job completed successfully. This value should be supported.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_COMPLETED_SUCCESSFULLY = new JobStateReason(24);
|
|
|
|
/**
|
|
* The job completed with warnings. This value should be supported if the
|
|
* implementation detects warnings.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_COMPLETED_WITH_WARNINGS = new JobStateReason(25);
|
|
|
|
/**
|
|
* The job completed with errors (and possibly warnings too). This value
|
|
* should be supported if the implementation detects errors.
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_COMPLETED_WITH_ERRORS = new JobStateReason(26);
|
|
|
|
/**
|
|
* This job is retained and is currently able to be restarted. If
|
|
* JOB_RESTARTABLE is contained in the job's {@link JobStateReasons
|
|
* JobStateReasons} attribute, then the printer must accept a request to
|
|
* restart that job. This value should be supported if restarting jobs is
|
|
* supported. <I>[The capability for restarting jobs is not in the Java
|
|
* Print Service API at present.]</I>
|
|
*/
|
|
public static final JobStateReason
|
|
JOB_RESTARTABLE = new JobStateReason(27);
|
|
|
|
/**
|
|
* The job has been forwarded to a device or print system that is unable to
|
|
* send back status. The printer sets the job's {@link JobState JobState}
|
|
* attribute to COMPLETED and adds the QUEUED_IN_DEVICE reason to the job's
|
|
* {@link JobStateReasons JobStateReasons} attribute to indicate that the
|
|
* printer has no additional information about the job and never will have
|
|
* any better information.
|
|
*/
|
|
public static final JobStateReason
|
|
QUEUED_IN_DEVICE = new JobStateReason(28);
|
|
|
|
/**
|
|
* Construct a new job state reason enumeration value with the given
|
|
* integer value.
|
|
*
|
|
* @param value Integer value.
|
|
*/
|
|
protected JobStateReason(int value) {
|
|
super (value);
|
|
}
|
|
|
|
private static final String[] myStringTable = {
|
|
"job-incoming",
|
|
"job-data-insufficient",
|
|
"document-access-error",
|
|
"submission-interrupted",
|
|
"job-outgoing",
|
|
"job-hold-until-specified",
|
|
"resources-are-not-ready",
|
|
"printer-stopped-partly",
|
|
"printer-stopped",
|
|
"job-interpreting",
|
|
"job-queued",
|
|
"job-transforming",
|
|
"job-queued-for-marker",
|
|
"job-printing",
|
|
"job-canceled-by-user",
|
|
"job-canceled-by-operator",
|
|
"job-canceled-at-device",
|
|
"aborted-by-system",
|
|
"unsupported-compression",
|
|
"compression-error",
|
|
"unsupported-document-format",
|
|
"document-format-error",
|
|
"processing-to-stop-point",
|
|
"service-off-line",
|
|
"job-completed-successfully",
|
|
"job-completed-with-warnings",
|
|
"job-completed-with-errors",
|
|
"job-restartable",
|
|
"queued-in-device"};
|
|
|
|
private static final JobStateReason[] myEnumValueTable = {
|
|
JOB_INCOMING,
|
|
JOB_DATA_INSUFFICIENT,
|
|
DOCUMENT_ACCESS_ERROR,
|
|
SUBMISSION_INTERRUPTED,
|
|
JOB_OUTGOING,
|
|
JOB_HOLD_UNTIL_SPECIFIED,
|
|
RESOURCES_ARE_NOT_READY,
|
|
PRINTER_STOPPED_PARTLY,
|
|
PRINTER_STOPPED,
|
|
JOB_INTERPRETING,
|
|
JOB_QUEUED,
|
|
JOB_TRANSFORMING,
|
|
JOB_QUEUED_FOR_MARKER,
|
|
JOB_PRINTING,
|
|
JOB_CANCELED_BY_USER,
|
|
JOB_CANCELED_BY_OPERATOR,
|
|
JOB_CANCELED_AT_DEVICE,
|
|
ABORTED_BY_SYSTEM,
|
|
UNSUPPORTED_COMPRESSION,
|
|
COMPRESSION_ERROR,
|
|
UNSUPPORTED_DOCUMENT_FORMAT,
|
|
DOCUMENT_FORMAT_ERROR,
|
|
PROCESSING_TO_STOP_POINT,
|
|
SERVICE_OFF_LINE,
|
|
JOB_COMPLETED_SUCCESSFULLY,
|
|
JOB_COMPLETED_WITH_WARNINGS,
|
|
JOB_COMPLETED_WITH_ERRORS,
|
|
JOB_RESTARTABLE,
|
|
QUEUED_IN_DEVICE};
|
|
|
|
/**
|
|
* Returns the string table for class JobStateReason.
|
|
*/
|
|
protected String[] getStringTable() {
|
|
return (String[])myStringTable.clone();
|
|
}
|
|
|
|
/**
|
|
* Returns the enumeration value table for class JobStateReason.
|
|
*/
|
|
protected EnumSyntax[] getEnumValueTable() {
|
|
return (EnumSyntax[])myEnumValueTable.clone();
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the printing attribute class which is to be used as the "category"
|
|
* for this printing attribute value.
|
|
* <P>
|
|
* For class JobStateReason and any vendor-defined subclasses, the
|
|
* category is class JobStateReason itself.
|
|
*
|
|
* @return Printing attribute class (category), an instance of class
|
|
* {@link java.lang.Class java.lang.Class}.
|
|
*/
|
|
public final Class<? extends Attribute> getCategory() {
|
|
return JobStateReason.class;
|
|
}
|
|
|
|
/**
|
|
* Get the name of the category of which this attribute value is an
|
|
* instance.
|
|
* <P>
|
|
* For class JobStateReason and any vendor-defined subclasses, the
|
|
* category name is <CODE>"job-state-reason"</CODE>.
|
|
*
|
|
* @return Attribute category name.
|
|
*/
|
|
public final String getName() {
|
|
return "job-state-reason";
|
|
}
|
|
|
|
}
|