The Book class provides a representation of a document in
which pages may have different page formats and page painters. This
class uses the Pageable interface to interact with a
PrinterJob.

The Pageable implementation represents a set of
pages to be printed. The Pageable object returns
the total number of pages in the set as well as the
PageFormat and Printable for a specified page.

The PageFormat class describes the size and
orientation of a page to be printed.

The Paper class describes the physical characteristics of
a piece of paper.

When creating a Paper object, it is the application's
responsibility to ensure that the paper size and the imageable area
are compatible.  For example, if the paper size is changed from
11 x 17 to 8.5 x 11, the application might need to reduce the
imageable area so that whatever is printed fits on the page.

The Printable interface is implemented
by the print methods of the current
page painter, which is called by the printing
system to render a page.  When building a
Pageable, pairs of PageFormat
instances and instances that implement
this interface are used to describe each page. The
instance implementing Printable is called to
print the page's graphics.

A Printable(..) may be set on a PrinterJob.
When the client subsequently initiates printing by calling
PrinterJob.print(..) control

is handed to the printing system until all pages have been printed.
It does this by calling Printable.print(..) until
all pages in the document have been printed.
In using the Printable interface the printing
commits to image the contents of a page whenever
requested by the printing system.

The parameters to Printable.print(..) include a
PageFormat which describes the printable area of
the page, needed for calculating the contents that will fit the
page, and the page index, which specifies the zero-based print
stream index of the requested page.

For correct printing behaviour, the following points should be
observed:

 The printing system may request a page index more than once.
On each occasion equal PageFormat parameters will be supplied.

The printing system will call Printable.print(..)
with page indexes which increase monotonically, although as noted above,
the Printable should expect multiple calls for a page index
and that page indexes may be skipped, when page ranges are specified
by the client, or by a user through a print dialog.

If multiple collated copies of a document are requested, and the
printer cannot natively support this, then the document may be imaged
multiple times. Printing will start each copy from the lowest print
stream page index page.

With the exception of re-imaging an entire document for multiple
collated copies, the increasing page index order means that when
page N is requested if a client needs to calculate page break position,
it may safely discard any state related to pages < N, and make current
that for page N. "State" usually is just the calculated position in the
document that corresponds to the start of the page.

When called by the printing system the Printable must
inspect and honour the supplied PageFormat parameter as well as the
page index.  The format of the page to be drawn is specified by the
supplied PageFormat. The size, orientation and imageable area of the page
is therefore already determined and rendering must be within this
imageable area.
This is key to correct printing behaviour, and it has the
implication that the client has the responsibility of tracking
what content belongs on the specified page.

When the Printable is obtained from a client-supplied
Pageable then the client may provide different PageFormats
for each page index. Calculations of page breaks must account for this.

The PrinterAbortException class is a subclass of
PrinterException and is used to indicate that a user
or application has terminated the print job while it was in
the process of printing.

The PrinterException class and its subclasses are used
to indicate that an exceptional condition has occurred in the print
system.

The PrinterGraphics interface is implemented by
Graphics objects that are passed to
Printable objects to render a page. It allows an
application to find the PrinterJob object that is
controlling the printing.

The PrinterIOException class is a subclass of
PrinterException and is used to indicate that an IO error
of some sort has occurred while printing.

As of release 1.4, this exception has been retrofitted to conform to
the general purpose exception-chaining mechanism.  The
"IOException that terminated the print job"
that is provided at construction time and accessed via the
getIOException() method is now known as the cause,
and may be accessed via the Throwable.getCause() method,
as well as the aforementioned "legacy method."

The PrinterJob class is the principal class that controls
printing. An application calls methods in this class to set up a job,
optionally to invoke a print dialog with the user, and then to print
the pages of the job.