File: ps-print.el.html

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

About ps-print
--------------

This package provides printing of Emacs buffers on PostScript printers; the buffer's bold and italic text attributes are preserved in the printer output. ps-print is intended for use with Emacs, together with a fontifying package such as font-lock or hilit.

ps-print uses the same face attributes defined through font-lock or hilit to print a PostScript file, but some faces are better seeing on the screen than on paper, specially when you have a black/white PostScript printer.

ps-print allows a remap of face to another one that it is better to print, for example, the face font-lock-comment-face (if you are using font-lock) could have bold or italic attribute when printing, besides foreground color. This remap improves printing look (see How Ps-Print Maps Faces).

Using ps-print
--------------

ps-print provides eight commands for generating PostScript images of Emacs buffers:

       ps-print-buffer
       ps-print-buffer-with-faces
       ps-print-region
       ps-print-region-with-faces
       ps-spool-buffer
       ps-spool-buffer-with-faces
       ps-spool-region
       ps-spool-region-with-faces

These commands all perform essentially the same function: they generate PostScript images suitable for printing on a PostScript printer or displaying with GhostScript. These commands are collectively referred to as
"ps-print- commands".

The word "print" or "spool" in the command name determines when the PostScript image is sent to the printer:

       print - The PostScript image is immediately sent to the printer;

       spool - The PostScript image is saved temporarily in an Emacs
                    buffer. Many images may be spooled locally before
                    printing them. To send the spooled images to the
                    printer, use the command ps-despool.

The spooling mechanism was designed for printing lots of small files (mail messages or netnews articles) to save paper that would otherwise be wasted on banner pages, and to make it easier to find your output at the printer
(it's easier to pick up one 50-page printout than to find 50 single-page
printouts).

ps-print has a hook in the kill-emacs-hook so that you won't accidentally quit from Emacs while you have unprinted PostScript waiting in the spool buffer. If you do attempt to exit with spooled PostScript, you'll be asked if you want to print it, and if you decline, you'll be asked to confirm the exit; this is modeled on the confirmation that Emacs uses for modified buffers.

The word "buffer" or "region" in the command name determines how much of the buffer is printed:

       buffer - Print the entire buffer.

       region - Print just the current region.

The -with-faces suffix on the command name means that the command will include font, color, and underline information in the PostScript image, so the printed image can look as pretty as the buffer. The ps-print- commands without the -with-faces suffix don't include font, color, or underline information; images printed with these commands aren't as pretty, but are faster to generate.

Two ps-print- command examples:

       ps-print-buffer - print the entire buffer, without font,
                                     color, or underline information, and
                                     send it immediately to the printer.

       ps-spool-region-with-faces - print just the current region; include
                                     font, color, and underline information,
                                     and spool the image in Emacs to send to
                                     the printer later.

Invoking Ps-Print
-----------------

To print your buffer, type

       M-x ps-print-buffer

or substitute one of the other seven ps-print- commands. The command will generate the PostScript image and print or spool it as specified. By giving the command a prefix argument

       C-u M-x ps-print-buffer

it will save the PostScript image to a file instead of sending it to the printer; you will be prompted for the name of the file to save the image to. The prefix argument is ignored by the commands that spool their images, but you may save the spooled images to a file by giving a prefix argument to ps-despool:

       C-u M-x ps-despool

When invoked this way, ps-despool will prompt you for the name of the file to save to.

Any of the ps-print- commands can be bound to keys; I recommend binding ps-spool-buffer-with-faces, ps-spool-region-with-faces, and ps-despool. Here are the bindings I use on my Sun 4 keyboard:

  (keymap-global-set "<f22>" #'ps-spool-buffer-with-faces) ;f22 is prsc
  (keymap-global-set "S-<f22>" #'ps-spool-region-with-faces)
  (keymap-global-set "C-<f22>" #'ps-despool)

The Printer Interface
---------------------

The variables ps-lpr-command and ps-lpr-switches determine what command is used to send the PostScript images to the printer, and what arguments to give the command. These are analogous to lpr-command and lpr-switches.

Make sure that they contain appropriate values for your system; see the usage notes below and the documentation of these variables.

The variable ps-printer-name determines the name of a local printer for printing PostScript files.

The variable ps-printer-name-option determines the option used by some utilities to indicate the printer name, it's used only when ps-printer-name is a non-empty string. If you're using lpr utility to print, for example, ps-printer-name-option should be set to "-P".

NOTE: ps-lpr-command and ps-lpr-switches take their initial values from
      the variables lpr-command and lpr-switches. If you have
      lpr-command set to invoke a pretty-printer such as enscript, then
      ps-print won't work properly. ps-lpr-command must name a program
      that does not format the files it prints.
      ps-printer-name takes its initial value from the variable
      printer-name. ps-printer-name-option tries to guess which system
      Emacs is running and takes its initial value in accordance with this
      guess.

The variable ps-print-region-function specifies a function to print the region on a PostScript printer. See definition of call-process-region for calling conventions. The fourth and the sixth arguments are both nil.

The variable ps-manual-feed indicates if the printer will manually feed paper. If it's nil, automatic feeding takes place. If it's non-nil, manual feeding takes place. The default is nil (automatic feeding).

The variable ps-end-with-control-d specifies whether C-d (\x04) should be inserted at end of PostScript generated. Non-nil means do so. The default is nil (don't insert).

If you're using Emacs for Windows 98/NT or MS-DOS, don't forget to customize the following variables: ps-printer-name, ps-printer-name-option, ps-lpr-command, ps-lpr-switches and ps-spool-config. See these variables documentation in the code or by typing, for example, C-h v ps-printer-name RET.

The Page Layout
---------------

All dimensions are floats in PostScript points.
1 inch == 2.54 cm == 72 points
1 cm == (/ 1 2.54) inch == (/ 72 2.54) points

The variable ps-paper-type determines the size of paper ps-print formats for; it should contain one of the symbols: a4 a3 letter legal letter-small tabloid ledger statement executive a4small b4 b5.

If variable ps-warn-paper-type is nil, it's *not* given an error if PostScript printer doesn't have a paper with the size indicated by ps-paper-type, instead it uses the default paper size. If variable ps-warn-paper-type is non-nil, it's given an error if PostScript printer doesn't have a paper with the size indicated by ps-paper-type. It's used when ps-spool-config is set to setpagedevice (see section Duplex Printers). The default value is non-nil (it gives an error).

The variable ps-landscape-mode determines the orientation of the printing on the page: nil means portrait mode, non-nil means landscape mode. There is no oblique mode yet, though this is easy to do in ps.

In landscape mode, the text is NOT scaled: you may print 70 lines in portrait mode and only 50 lines in landscape mode. The margins represent margins in the printed paper: the top margin is the margin between the top of the page and the printed header, whatever the orientation is.

The variable ps-number-of-columns determines the number of columns both in landscape and portrait mode. You can use:
- (the standard) one column portrait mode.
- (my favorite) two columns landscape mode (which spares trees).
but also:
- one column landscape mode for files with very long lines.
- multi-column portrait or landscape mode.

The variable ps-print-upside-down determines other orientation for printing page: nil means normal printing, non-nil means upside-down printing (that is, the page is rotated by 180 grades). The default value is nil (normal printing).

The upside-down orientation can be used in portrait or landscape mode.

The variable ps-selected-pages(var)/ps-selected-pages(fun) specifies which pages to print. If it's nil, all pages are printed. If it's a list, the list element may be an integer or a cons cell (FROM . TO) designating FROM page to TO page; any invalid element is ignored, that is, an integer lesser than one or if FROM is greater than TO. Otherwise, it's treated as nil. The default value is nil (print all pages). After ps-print processing ps-selected-pages(var)/ps-selected-pages(fun) is set to nil. But the latest ps-selected-pages(var)/ps-selected-pages(fun) is saved in ps-last-selected-pages (see it for documentation). So you can restore the latest selected pages by using ps-last-selected-pages or by calling ps-restore-selected-pages command (see it for documentation).

The variable ps-even-or-odd-pages specifies if it prints even/odd pages.

Valid values are:

nil print all pages.

even-page print only even pages.

odd-page print only odd pages.

even-sheet print only even sheets.

odd-sheet print only odd sheets.

Any other value is treated as nil. The default value is nil.

See ps-even-or-odd-pages for more detailed documentation.

Horizontal layout
-----------------

The horizontal layout is determined by the variables ps-left-margin ps-inter-column ps-right-margin as follows:

 ------------------------------------------
 | | | | | | | |
 | lm | text | ic | text | ic | text | rm |
 | | | | | | | |
 ------------------------------------------

If ps-number-of-columns is 1, ps-inter-column is not relevant. Usually, lm = rm > 0 and ic = lm If (ic < 0), the text of adjacent columns can overlap.

Vertical layout
---------------

The vertical layout is determined by the variables ps-bottom-margin ps-top-margin ps-header-offset ps-footer-offset as follows:

|--------| |--------| |--------| |--------|
| tm | | tm | | tm | | tm |
|--------| |--------| |--------| |--------|
| header | | | | header | | |
|--------| | | |--------| | |
| ho | | | | ho | | |
|--------| | | |--------| | |
| | | | | | | |
| text | or | text | or | text | or | text |
| | | | | | | |
| | |--------| |--------| | |
| | | fo | | fo | | |
| | |--------| |--------| | |
| | | footer | | footer | | |
|--------| |--------| |--------| |--------|
| bm | | bm | | bm | | bm |
|--------| |--------| |--------| |--------|

If ps-print-header is nil, ps-header-offset is not relevant. If ps-print-footer is nil, ps-footer-offset is not relevant. The margins represent margins in the printed paper: the top margin is the margin between the top of the page and the printed header, whatever the orientation is; the bottom margin is the margin between the bottom of the page and the printed footer, whatever the orientation is.

Headers & Footers
-----------------

ps-print can print headers at the top of each column or at the top of each page; the default headers contain the following four items: on the left, the name of the buffer and, if the buffer is visiting a file, the file's directory; on the right, the page number and date of printing. The default headers look something like this:

    ps-print.el 1/21
    /home/jct/emacs-lisp/ps/new 94/12/31

When printing on duplex printers, left and right are reversed so that the page numbers are toward the outside (cf. ps-spool-duplex).

Headers are configurable: To turn them off completely, set ps-print-header to nil. To turn off the header's gaudy framing box, set ps-print-header-frame to nil.

The variable ps-header-frame-alist specifies header frame properties alist. Valid frame properties are:

  fore-color Specify the foreground frame color.
It should be a float number between 0.0 (black color)
and 1.0 (white color), a string which is a color name,
or a list of 3 float numbers which corresponds to the
Red Green Blue color scale, each float number between
0.0 (dark color) and 1.0 (bright color).
The default is 0 ("black").

  back-color Specify the background frame color (similar to
fore-color). The default is 0.9 ("gray90").

  shadow-color Specify the shadow color (similar to fore-color).
The default is 0 ("black").

  border-color Specify the border color (similar to fore-color).
The default is 0 ("black").

  border-width Specify the border width.
The default is 0.4.

Any other property is ignored.

Don't change this alist directly, instead use customization, or ps-value, ps-get, ps-put and ps-del functions (see them for documentation).

To print only one header at the top of each page, set ps-print-only-one-header to t.

To switch headers, set ps-switch-header to:

   nil Never switch headers.

   t Always switch headers.

   duplex Switch headers only when duplexing is on, that is, when
ps-spool-duplex is non-nil (see Duplex Printers).

Any other value is treated as t. The default value is duplex.

The font family and size of text in the header are determined by the variables ps-header-font-family, ps-header-font-size and ps-header-title-font-size (see below).

The variable ps-header-line-pad determines the portion of a header title line height to insert between the header frame and the text it contains, both in the vertical and horizontal directions: .5 means half a line.

Page numbers are printed in n/m format, indicating page n of m pages; to omit the total page count and just print the page number, set ps-show-n-of-n to nil.

The amount of information in the header can be changed by changing the number of lines. To show less, set ps-header-lines to 1, and the header will show only the buffer name and page number. To show more, set ps-header-lines to 3, and the header will show the time of printing below the date.

To change the content of the headers, change the variables ps-left-header and ps-right-header. These variables are lists, specifying top-to-bottom the text to display on the left or right side of the header. Each element of the list should be a string or a symbol. Strings are inserted directly into the PostScript arrays, and should contain the PostScript string delimiters '(' and ')'.

Symbols in the header format lists can either represent functions or variables. Functions are called, and should return a string to show in the header. Variables should contain strings to display in the header. In either case, function or variable, the PostScript string delimiters are added by ps-print, and should not be part of the returned value.

Here's an example: say we want the left header to display the text

    Moe
    Larry
    Curly

where we have a function to return "Moe"

    (defun moe-func ()
      "Moe")

a variable specifying "Larry"

    (setq larry-var "Larry")

and a literal for "Curly". Here's how ps-left-header should be set:

    (setq ps-left-header (list 'moe-func 'larry-var "(Curly)"))

Note that Curly has the PostScript string delimiters inside his quotes -- those aren't misplaced Lisp delimiters!

Without them, PostScript would attempt to call the undefined function Curly, which would result in a PostScript error.

Since most printers don't report PostScript errors except by aborting the print job, this kind of error can be hard to track down.

Consider yourself warned!

ps-print also print footers. The footer variables are: ps-print-footer, ps-footer-offset, ps-print-footer-frame, ps-footer-font-family, ps-footer-font-size, ps-footer-line-pad, ps-footer-lines, ps-left-footer, ps-right-footer and ps-footer-frame-alist. These variables are similar to those one that control headers.

The variables ps-print-only-one-header and ps-switch-header also control the footer (The same way that control header).

As a footer example, if you want to have a centered page number in the footer but without headers, set:

   (setq ps-print-header nil
         ps-print-footer t
         ps-print-footer-frame nil
         ps-footer-lines 1
         ps-right-footer nil
         ps-left-footer
         (list (concat "{pagenumberstring dup stringwidth pop"
                       " 2 div PrintWidth 2 div exch sub 0 rmoveto}")))

PostScript Prologue Header
--------------------------

It is possible to add PostScript prologue header comments besides that ps-print generates by setting the variable ps-print-prologue-header.

ps-print-prologue-header may be a string or a symbol function which returns a string. Note that this string is inserted on PostScript prologue header section which is used to define some document characteristic through PostScript special comments, like "%%Requirements: jog\\n".

By default ps-print-prologue-header is nil.

ps-print always inserts the %%Requirements: comment, so if you need to insert more requirements put them first in ps-print-prologue-header using the "%%+" comment. For example, if you need to set numcopies to 3 and jog on requirements and set %%LanguageLevel: to 2, do:

(setq ps-print-prologue-header
      "%%+ numcopies(3) jog\\n%%LanguageLevel: 2\\n")

The duplex requirement is inserted by ps-print (see section Duplex Printers).

Do not forget to terminate the string with "\\n".

For more information about PostScript document comments, see:
   PostScript Language Reference Manual (2nd edition)
   Adobe Systems Incorporated
   Appendix G: Document Structuring Conventions -- Version 3.0

It is also possible to add an user defined PostScript prologue code before all generated prologue code by setting the variable ps-user-defined-prologue.

ps-user-defined-prologue may be a string or a symbol function which returns a string. Note that this string is inserted after ps-adobe-tag and PostScript prologue comments, and before ps-print PostScript prologue code section. That is, this string is inserted after error handler initialization and before ps-print settings.

By default ps-user-defined-prologue is nil.

It's strongly recommended only insert PostScript code and/or comments specific for your printing system particularities. For example, some special initialization that only your printing system needs.

Do not insert code for duplex printing, n-up printing or error handler, ps-print handles this in a suitable way.

For more information about PostScript, see:
   PostScript Language Reference Manual (2nd edition)
   Adobe Systems Incorporated

As an example for ps-user-defined-prologue setting:

  ;; Setting for HP PostScript printer
  (setq ps-user-defined-prologue
   (concat "<</DeferredMediaSelection true /PageSize [612 792] "
"/MediaPosition 2 /MediaType (Plain)>> setpagedevice"))

PostScript Error Handler
------------------------

ps-print instruments generated PostScript code with an error handler.

The variable ps-error-handler-message specifies where the error handler message should be sent.

Valid values are:

none catch the error and *DON'T* send any message.

paper catch the error and print on paper the error message.
This is the default value.

system catch the error and send back the error message to
printing system. This is useful only if printing
system send back an email reporting the error, or if
there is some other alternative way to report back the
error from the system to you.

paper-and-system catch the error, print on paper the error message and
send back the error message to printing system.

Any other value is treated as paper.

Duplex Printers
---------------

If you have a duplex-capable printer (one that prints both sides of the paper), set ps-spool-duplex to t. ps-print will insert blank pages to make sure each buffer starts on the correct side of the paper.

The variable ps-spool-config specifies who is the responsible for setting duplex and page size. Valid values are:

lpr-switches duplex and page size are configured by ps-lpr-switches.
                Don't forget to set ps-lpr-switches to select duplex
                printing for your printer.

setpagedevice duplex and page size are configured by ps-print using the
                setpagedevice PostScript operator.

nil duplex and page size are configured by ps-print *not* using
                the setpagedevice PostScript operator.

Any other value is treated as nil.

The default value is lpr-switches.

WARNING: The setpagedevice PostScript operator affects ghostview utility
         when viewing file generated using landscape. Also on some
         printers, setpagedevice affects zebra stripes; on other printers,
         setpagedevice affects the left margin.
         Besides all that, if your printer does not have the paper size
         specified by setpagedevice, your printing will be aborted.
         So, if you need to use setpagedevice, set ps-spool-config to
         setpagedevice, generate a test file and send it to your printer;
         if the printed file isn't ok, set ps-spool-config to nil.

The variable ps-spool-tumble specifies how the page images on opposite sides of a sheet are oriented with respect to each other. If ps-spool-tumble is nil, produces output suitable for binding on the left or right. If ps-spool-tumble is non-nil, produces output suitable for binding at the top or bottom. It has effect only when ps-spool-duplex is non-nil. The default value is nil.

Some printer system prints a header page and forces the first page be printed on header page back, when using duplex. If your printer system has this behavior, set variable ps-banner-page-when-duplexing to t.

When ps-banner-page-when-duplexing is non-nil, it prints a blank page as the very first printed page. So, it behaves as the very first character of buffer (or region) is ^L (\014).

The default for ps-banner-page-when-duplexing is nil (*don't* skip the very first page).

N-up Printing
-------------

The variable ps-n-up-printing(var)/ps-n-up-printing(fun) specifies the number of pages per sheet of paper. The value specified must be between 1 and 100. The default is 1.

NOTE: some PostScript printer may crash printing if ps-n-up-printing(var)/ps-n-up-printing(fun) is set to a high value (for example, 23). If this happens, set a lower value.

The variable ps-n-up-margin specifies the margin in points between the sheet border and the n-up printing. The default is 1 cm (or 0.3937 inches, or 28.35 points).

If variable ps-n-up-border-p is non-nil a border is drawn around each page. The default is t.

The variable ps-n-up-filling(var)/ps-n-up-filling(fun) specifies how page matrix is filled on each sheet of paper. Following are the valid values for ps-n-up-filling(var)/ps-n-up-filling(fun) with a filling example using a 3x4 page matrix:

 left-top 1 2 3 4 left-bottom 9 10 11 12
            5 6 7 8 5 6 7 8
            9 10 11 12 1 2 3 4

 right-top 4 3 2 1 right-bottom 12 11 10 9
            8 7 6 5 8 7 6 5
            12 11 10 9 4 3 2 1

 top-left 1 4 7 10 bottom-left 3 6 9 12
            2 5 8 11 2 5 8 11
            3 6 9 12 1 4 7 10

 top-right 10 7 4 1 bottom-right 12 9 6 3
            11 8 5 2 11 8 5 2
            12 9 6 3 10 7 4 1

Any other value is treated as left-top.

The default value is left-top.

Control And 8-bit Characters
----------------------------

The variable ps-print-control-characters specifies whether you want to see a printable form for control and 8-bit characters, that is, instead of sending, for example, a ^D (\004) to printer, it is sent the string "^D".

Valid values for ps-print-control-characters are:

 8-bit This is the value to use when you want an ASCII encoding of
                 any control or non-ASCII character. Control characters are
                 encoded as "^D", and non-ASCII characters have an
                 octal encoding.

 control-8-bit This is the value to use when you want an ASCII encoding of
                 any control character, whether it is 7 or 8-bit.
                 European 8-bits accented characters are printed according
                 the current font.

 control Only ASCII control characters have an ASCII encoding.
                 European 8-bits accented characters are printed according
                 the current font.

 nil No ASCII encoding. Any character is printed according the
                 current font.

Any other value is treated as nil.

The default is control-8-bit.

Characters TAB, NEWLINE and FORMFEED are always treated by ps-print engine.

Printing Multi-byte Buffer
--------------------------

See ps-mule.el for documentation.

Line Number
-----------

The variable ps-line-number specifies whether to number each line; non-nil means do so. The default is nil (don't number each line).

The variable ps-line-number-color specifies the color for line number. See ps-zebra-color for documentation. The default is "black" (or 0.0, or
'(0.0 0.0 0.0)).

The variable ps-line-number-font specifies the font for line number. The default is "Times-Italic".

The variable ps-line-number-font-size specifies the font size in points for line number. See ps-font-size for documentation. The default is 6.

The variable ps-line-number-step specifies the interval that line number is printed. For example, if ps-line-number-step is set to 2, the printing will look like:

   1 one line
     one line
   3 one line
     one line
   5 one line
     one line
     ...

Valid values are:

integer an integer that specifies the interval that line number is
printed. If it's lesser than or equal to zero, it's used the
value 1.

zebra specifies that only the line number of the first line in a
zebra stripe is to be printed.

Any other value is treated as zebra. The default value is 1, so each line number is printed.

The variable ps-line-number-start specifies the starting point in the interval given by ps-line-number-step. For example, if ps-line-number-step is set to 3 and ps-line-number-start is set to 3, the printing will look like:

     one line
     one line
   3 one line
     one line
     one line
   6 one line
     one line
     one line
   9 one line
     one line
     ...

The values for ps-line-number-start:

   * If ps-line-number-step is an integer, must be between 1 and the value
of ps-line-number-step inclusive.

   * If ps-line-number-step is set to zebra, must be between 1 and the
value of ps-zebra-stripe-height inclusive.

The default value is 1, so the line number of the first line of each interval is printed.

Zebra Stripes
-------------

Zebra stripes are a kind of background that appear "underneath" the text and can make the text easier to read. They look like this:

XXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXX

The blocks of X's represent rectangles filled with a light gray color. Each rectangle extends all the way across the page.

The height, in lines, of each rectangle is controlled by the variable ps-zebra-stripe-height, which is 3 by default. The distance between stripes equals the height of a stripe.

The variable ps-zebra-stripes controls whether to print zebra stripes. Non-nil means yes, nil means no. The default is nil.

The variable ps-zebra-color controls the zebra stripes gray scale or RGB color. It should be a float number between 0.0 (black color) and 1.0 (white color), a string which is a color name, or a list of 3 numbers which corresponds to the Red Green Blue color scale. The default is 0.95 (or "gray95", or '(0.95 0.95 0.95)).

The variable ps-zebra-stripe-follow specifies how zebra stripes continue on next page. Visually, valid values are (the character + at right of each column indicates that a line is printed):

nil follow full full-follow
Current Page -------- ----------- --------- ----------------
1 XXXXX + 1 XXXXXXXX + 1 XXXXXX + 1 XXXXXXXXXXXXX +
2 XXXXX + 2 XXXXXXXX + 2 XXXXXX + 2 XXXXXXXXXXXXX +
3 XXXXX + 3 XXXXXXXX + 3 XXXXXX + 3 XXXXXXXXXXXXX +
4 + 4 + 4 + 4 +
5 + 5 + 5 + 5 +
6 + 6 + 6 + 6 +
7 XXXXX + 7 XXXXXXXX + 7 XXXXXX + 7 XXXXXXXXXXXXX +
8 XXXXX + 8 XXXXXXXX + 8 XXXXXX + 8 XXXXXXXXXXXXX +
9 XXXXX + 9 XXXXXXXX + 9 XXXXXX + 9 XXXXXXXXXXXXX +
10 + 10 +
11 + 11 +
-------- ----------- --------- ----------------
   Next Page -------- ----------- --------- ----------------
12 XXXXX + 12 + 10 XXXXXX + 10 +
13 XXXXX + 13 XXXXXXXX + 11 XXXXXX + 11 +
14 XXXXX + 14 XXXXXXXX + 12 XXXXXX + 12 +
15 + 15 XXXXXXXX + 13 + 13 XXXXXXXXXXXXX +
16 + 16 + 14 + 14 XXXXXXXXXXXXX +
17 + 17 + 15 + 15 XXXXXXXXXXXXX +
18 XXXXX + 18 + 16 XXXXXX + 16 +
19 XXXXX + 19 XXXXXXXX + 17 XXXXXX + 17 +
20 XXXXX + 20 XXXXXXXX + 18 XXXXXX + 18 +
21 + 21 XXXXXXXX +
22 + 22 +
-------- ----------- --------- ----------------

Any other value is treated as nil.

See also section How Ps-Print Has A Text And/Or Image On Background.

Hooks
-----

ps-print has the following hook variables:

ps-print-hook
   It is evaluated once before any printing process. This is the right
   place to initialize ps-print global data.
   For an example, see section Adding a New Font Family.

ps-print-begin-sheet-hook
   It is evaluated on each beginning of sheet of paper.
   If ps-n-up-printing(var)/ps-n-up-printing(fun) is equal to 1, ps-print-begin-page-hook is never
   evaluated.

ps-print-begin-page-hook
   It is evaluated on each beginning of page, except in the beginning of
   page that ps-print-begin-sheet-hook is evaluated.

ps-print-begin-column-hook
   It is evaluated on each beginning of column, except in the beginning of
   column that ps-print-begin-page-hook is evaluated or that
   ps-print-begin-sheet-hook is evaluated.

Font Managing
-------------

ps-print now knows rather precisely some fonts: the variable ps-font-info-database contains information for a list of font families
(currently mainly Courier Helvetica Times Palatino
Helvetica-Narrow NewCenturySchlbk). Each font family contains the font names for standard, bold, italic and bold-italic characters, a reference size (usually 10) and the corresponding line height, width of a space and average character width.

The variable ps-font-family determines which font family is to be used for ordinary text. If its value does not correspond to a known font family, an error message is printed into the *Messages* buffer, which lists the currently available font families.

The variable ps-font-size determines the size (in points) of the font for ordinary text, when generating PostScript. Its value is a float or a cons of floats which has the following form:

   (LANDSCAPE-SIZE . PORTRAIT-SIZE)

Similarly, the variable ps-header-font-family determines which font family is to be used for text in the header.

The variable ps-header-font-size determines the font size, in points, for text in the header (similar to ps-font-size).

The variable ps-header-title-font-size determines the font size, in points, for the top line of text in the header (similar to ps-font-size).

The variable ps-line-spacing determines the line spacing, in points, for ordinary text, when generating PostScript (similar to ps-font-size). The default value is 0 (zero = no line spacing).

The variable ps-paragraph-spacing determines the paragraph spacing, in points, for ordinary text, when generating PostScript (similar to ps-font-size). The default value is 0 (zero = no paragraph spacing).

To get all lines with some spacing set both ps-line-spacing and ps-paragraph-spacing variables.

The variable ps-paragraph-regexp specifies the paragraph delimiter. It should be a regexp or nil. The default value is "[ \\t]*$", that is, an empty line or a line containing only spaces and tabs.

The variable ps-begin-cut-regexp and ps-end-cut-regexp specify the start and end of a region to cut out when printing.

As an example, variables ps-begin-cut-regexp and ps-end-cut-regexp may be set to "^Local Variables:" and "^End:", respectively, in order to leave out some special printing instructions from the actual print. Special printing instructions may be appended to the end of the file just like any other buffer-local variables. See section "Local Variables in Files" on Emacs manual for more information.

Variables ps-begin-cut-regexp and ps-end-cut-regexp control together what actually gets printed. Both variables may be set to nil in which case no cutting occurs. By default, both variables are set to nil.

Adding a New Font Family
------------------------

To use a new font family, you MUST first teach ps-print this font, i.e., add its information to ps-font-info-database, otherwise ps-print cannot correctly place line and page breaks.

For example, assuming Helvetica is unknown, you first need to do the following ONLY ONCE:

- create a new buffer
- generate the PostScript image to a file (C-u M-x ps-print-buffer)
- open this file and find the line:
% 3 cm 20 cm moveto 10/Courier ReportFontInfo showpage
- delete the leading % (which is the PostScript comment character)
- replace in this line Courier by the new font (say Helvetica) to get
  the line:
3 cm 20 cm moveto 10/Helvetica ReportFontInfo showpage
- send this file to the printer (or to ghostscript).
  You should read the following on the output page:

    For Helvetica 10 point, the line height is 11.56, the space width is 2.78
    and a crude estimate of average character width is 5.09243

- Add these values to the ps-font-info-database:
  (setq ps-font-info-database
   (append
    '((Helvetica ; the family key
       (fonts (normal . "Helvetica")
(bold . "Helvetica-Bold")
(italic . "Helvetica-Oblique")
(bold-italic . "Helvetica-BoldOblique"))
       (size . 10.0)
       (line-height . 11.56)
       (space-width . 2.78)
       (avg-char-width . 5.09243)))
    ps-font-info-database))
- Now you can use this font family with any size:
(setq ps-font-family 'Helvetica)
- if you want to use this family in another Emacs session, you must put into
  your ~/.emacs:
(require 'ps-print)
(setq ps-font-info-database (append ...)))
  if you don't want to load ps-print, you have to copy the whole value:
(setq ps-font-info-database '(<your stuff> <the standard stuff>))
  or, use ps-print-hook (see section Hooks):
(add-hook 'ps-print-hook
(lambda ()
(or (assq 'Helvetica ps-font-info-database)
(setq ps-font-info-database (append ...)))))

You can create new mixed font families like:
     (my-mixed-family
      (fonts (normal . "Courier-Bold")
             (bold . "Helvetica")
             (italic . "ZapfChancery-MediumItalic")
             (bold-italic . "NewCenturySchlbk-BoldItalic")
             (w3-table-hack-x-face . "LineDrawNormal"))
      (size . 10.0)
      (line-height . 10.55)
      (space-width . 6.0)
      (avg-char-width . 6.0))

Now you can use your new font family with any size:
(setq ps-font-family 'my-mixed-family)

Note that on above example the w3-table-hack-x-face entry refers to a face symbol, so when printing this face it'll be used the font LineDrawNormal. If the face w3-table-hack-x-face is remapped to use bold and/or italic attribute, the corresponding entry (bold, italic or bold-italic) will be used instead of w3-table-hack-x-face entry.

Note also that the font family entry order is irrelevant, so the above example could also be written:
     (my-mixed-family
      (size . 10.0)
      (fonts (w3-table-hack-x-face . "LineDrawNormal")
             (bold . "Helvetica")
             (bold-italic . "NewCenturySchlbk-BoldItalic")
             (italic . "ZapfChancery-MediumItalic")
             (normal . "Courier-Bold"))
      (avg-char-width . 6.0)
      (space-width . 6.0)
      (line-height . 10.55))

Despite the note above, it is recommended that some convention about entry order be used.

You can get information on all the fonts resident in YOUR printer by uncommenting the line:
% 3 cm 20 cm moveto ReportAllFontInfo showpage

The PostScript file should be sent to YOUR PostScript printer. If you send it to ghostscript or to another PostScript printer, you may get slightly different results. Anyway, as ghostscript fonts are autoload, you won't get much font info.

Note also that ps-print DOESN'T download any font to your printer, instead it uses the fonts resident in your printer.

How Ps-Print Deals With Faces
-----------------------------

The ps-print-*-with-faces commands attempt to determine which faces should be printed in bold or italic, but their guesses aren't always right. For example, you might want to map colors into faces so that blue faces print in bold, and red faces in italic.

It is possible to force ps-print to consider specific faces bold, italic or underline, no matter what font they are displayed in, by setting the variables ps-bold-faces, ps-italic-faces and ps-underlined-faces. These variables contain lists of faces that ps-print should consider bold, italic or underline; to set them, put code like the following into your init file:

     (setq ps-bold-faces '(my-blue-face))
     (setq ps-italic-faces '(my-red-face))
     (setq ps-underlined-faces '(my-green-face))

Faces like bold-italic that are both bold and italic should go in *both* lists.

ps-print keeps internal lists of which fonts are bold and which are italic; these lists are built the first time you invoke ps-print. For the sake of efficiency, the lists are built only once; the same lists are referred in later invocations of ps-print.

Because these lists are built only once, it's possible for them to get out of sync, if a face changes, or if new faces are added. To get the lists back in sync, you can set the variable ps-build-face-reference to t, and the lists will be rebuilt the next time ps-print is invoked. If you need that the lists always be rebuilt when ps-print is invoked, set the variable ps-always-build-face-reference to t.

If you need to print without worrying about face background color, set the variable ps-use-face-background which specifies if face background should be used. Valid values are:

   t always use face background color.
   nil never use face background color.
   (face...) list of faces whose background color will be used.

Any other value will be treated as t. The default value is nil.

How Ps-Print Deals With Color
-----------------------------

ps-print detects faces with foreground and background colors defined and embeds color information in the PostScript image. The default foreground and background colors are defined by the variables ps-default-fg and ps-default-bg. On black/white printers, colors are displayed in gray scale. To turn off color output, set ps-print-color-p to nil. You can also set ps-print-color-p to 'black-white to have a better looking on black/white printers. See also ps-black-white-faces for documentation.

ps-print also detects if the text foreground and background colors are equals when ps-fg-validate-p is non-nil. In this case, if these colors are used, no text will appear. You can use ps-fg-list to give a list of foreground colors to be used when text foreground and background colors are equals. It'll be used the first foreground color in ps-fg-list which is different from the background color. If ps-fg-list is nil, the default foreground color is used.

How Ps-Print Maps Faces
-----------------------

As ps-print uses PostScript to print buffers, it is possible to have other attributes associated with faces. So the new attributes used by ps-print are:

  strikeout - like underline, but the line is in middle of text.
  overline - like underline, but the line is over the text.
  shadow - text will have a shadow.
  box - text will be surrounded by a box.
  outline - print characters as hollow outlines.

See the documentation for ps-extend-face.

Let's, for example, remap font-lock-keyword-face to another foreground color and bold attribute:

   (ps-extend-face '(font-lock-keyword-face "RoyalBlue" nil bold) 'MERGE)

If you want to use a new face, define it first with defface, and then call ps-extend-face to specify how to print it.

How Ps-Print Has A Text And/Or Image On Background
--------------------------------------------------

ps-print can print texts and/or EPS PostScript images on background; it is possible to define the following text attributes: font name, font size, initial position, angle, gray scale and pages to print.

It has the following EPS PostScript images attributes: file name containing the image, initial position, X and Y scales, angle and pages to print.

See documentation for ps-print-background-text and ps-print-background-image.

For example, if we wish to print text "preliminary" on all pages and text
"special" on page 5 and from page 11 to page 17, we could specify:

(setq ps-print-background-text
      '(("preliminary")
        ("special"
         "LeftMargin" "BottomMargin PrintHeight add" ; X and Y position
                                     ; (upper left corner)
         nil nil nil
         "PrintHeight neg PrintPageWidth atan" ; angle
         5 (11 . 17)) ; page list
        ))

Similarly, we could print image "~/images/EPS-image1.ps" on all pages and image "~/images/EPS-image2.ps" on page 5 and from page 11 to page 17, we specify:

(setq ps-print-background-image
      '(("~/images/EPS-image1.ps"
         "LeftMargin" "BottomMargin") ; X and Y position (lower left corner)
        ("~/images/EPS-image2.ps"
         "LeftMargin" "BottomMargin PrintHeight 2 div add" ; X and Y pos.
                                     ; (upper left corner)
         nil nil nil
         5 (11 . 17)) ; page list
        ))

If it is not possible to read (or does not exist) an image file, that file is ignored.

The printing order is:

   1. Print background color
   2. Print zebra stripes
   3. Print background texts that it should be on all pages
   4. Print background images that it should be on all pages
   5. Print background texts only for current page (if any)
   6. Print background images only for current page (if any)
   7. Print header
   8. Print buffer text (with faces, if specified) and line number

Utilities
---------

Some tools are provided to help you customize your font setup.

ps-setup returns (some part of) the current setup.

To avoid wrapping too many lines, you may want to adjust the left and right margins and the font size. On UN*X systems, do: pr -t file | awk '{printf "%3d %s\\n", length($0), $0}' | sort -r | head to determine the longest lines of your file. Then, the command ps-line-lengths will give you the correspondence between a line length (number of characters) and the maximum font size which doesn't wrap such a line with the current ps-print setup.

The commands ps-nb-pages-buffer and ps-nb-pages-region display the correspondence between a number of pages and the maximum font size which allow the number of lines of the current buffer or of its current region to fit in this number of pages.

NOTE: line folding is not taken into account in this process and could
      change the results.

The command ps-print-customize activates a customization buffer for ps-print options.

New since version 1.5
---------------------

Color output capability. Automatic detection of font attributes (bold, italic). Configurable headers with page numbers. Slightly faster. Support for different paper sizes. Better conformance to PostScript Document Structure Conventions.

New since version 2.8
---------------------

[vinicius] Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>

   2007-10-27
 ps-fg-validate-p, ps-fg-list

   2004-02-29
 ps-time-stamp-yyyy-mm-dd, ps-time-stamp-iso8601

   2001-06-19
 ps-time-stamp-locale-default

   2001-05-30
 Handle before-string and after-string overlay properties.

   2001-04-07
 ps-line-number-color, ps-print-footer, ps-footer-offset,
 ps-print-footer-frame, ps-footer-font-family,
 ps-footer-font-size, ps-footer-line-pad, ps-footer-lines,
 ps-left-footer, ps-right-footer, ps-footer-frame-alist and
 ps-header-frame-alist.

   2001-03-28
 ps-line-spacing, ps-paragraph-spacing, ps-paragraph-regexp,
 ps-begin-cut-regexp and ps-end-cut-regexp.

   2000-11-22
 ps-line-number-font, ps-line-number-font-size and
 ps-end-with-control-d.

   2000-08-21
 ps-even-or-odd-pages

   2000-06-17
 ps-manual-feed, ps-warn-paper-type, ps-print-upside-down,
 ps-selected-pages(var)/ps-selected-pages(fun), ps-last-selected-pages,
 ps-restore-selected-pages, ps-switch-header,
 ps-line-number-step, ps-line-number-start,
 ps-zebra-stripe-follow and ps-use-face-background.

   2000-03-10
 PostScript error handler.
 ps-user-defined-prologue and ps-error-handler-message.

   1999-12-11
 ps-print-customize.

   1999-07-03
 Better customization.
 ps-banner-page-when-duplexing and ps-zebra-color.

   1999-05-13
 N-up printing.
 Hook: ps-print-begin-sheet-hook.

[kenichi] 1999-05-09 Ken'ichi Handa <handa@m17n.org>

   ps-print-region-function

[vinicius] Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>

   1999-03-01
 PostScript tumble and setpagedevice.

   1998-09-22
 PostScript prologue header comment insertion.
 Skip invisible text better.

[kenichi] 1998-08-19 Ken'ichi Handa <handa@m17n.org>

   Multi-byte buffer handling.

[vinicius] Vinicius Jose Latorre <viniciusjl.gnu@gmail.com>

   1998-03-06
 Skip invisible text.

   1997-11-30
 Hooks: ps-print-hook, ps-print-begin-page-hook and
 ps-print-begin-column-hook.
 Put one header per page over the columns.
 Better database font management.
 Better control characters handling.

   1997-11-21
 Dynamic evaluation at print time of ps-lpr-switches.
 Handle control characters.
 Face remapping.
 New face attributes.
 Line number.
 Zebra stripes.
 Text and/or image on background.

[jack] 1996-05-17 Jacques Duthen <duthen@cegelec-red.fr>

   Font family and float size for text and header.
   Landscape mode.
   Multiple columns.
   Tools for page setup.

Known bugs and limitations of ps-print
--------------------------------------

Automatic font-attribute detection doesn't work well. Users having problems with auto-font detection should use the lists ps-italic-faces, ps-bold-faces and ps-underlined-faces and/or turn off automatic detection by setting ps-auto-font-detect to nil.

Still too slow; could use some hand-optimization.

Default background color isn't working.

Faces are always treated as opaque.

Fixed-pitch fonts work better for line folding, but are not required.

ps-nb-pages-buffer and ps-nb-pages-region don't take care of folding lines.

Things to change
----------------

Avoid page break inside a paragraph.

Add ps-non-bold-faces and ps-non-italic-faces (should be easy).

Improve the memory management for big files (hard?).

ps-nb-pages-buffer and ps-nb-pages-region should take care of folding lines.

Acknowledgments
---------------

Thanks to Eduard Wiebe <usenet@pusto.de> for fixing face background/foreground extraction.

Thanks to Friedrich Delgado Friedrichs <friedel@nomaden.org> for new label printer page sizes.

Thanks to Michael Piotrowski <mxp@dynalabs.de> for improving the DSC compliance of the generated PostScript.

Thanks to Adam Doppelt <adoppelt@avogadro.com> for face mapping suggestion for black/white PostScript printers.

Thanks to Toni Ronkko <tronkko@hytti.uku.fi> for line and paragraph spacing, region to cut out when printing and footer suggestions.

Thanks to Pavel Janik ml <Pavel@Janik.cz> for documentation correction.

Thanks to Corinne Ilvedson <cilvedson@draper.com> for line number font size suggestion.

Thanks to Gord Wait <Gord_Wait@spectrumsignal.com> for ps-user-defined-prologue example setting for HP PostScript printer.

Thanks to Paul Furnanz <pfurnanz@synopsys.com> for XEmacs compatibility suggestion for ps-postscript-code-directory variable.

Thanks to David X Callaway <dxc@xprt.net> for helping debugging PostScript level 1 compatibility.

Thanks to Colin Marquardt <colin.marquardt@usa.alcatel.com> for:
   - upside-down, line number step, line number start and zebra stripe
follow suggestions.
   - ps-time-stamp-yyyy-mm-dd and ps-time-stamp-iso8601 suggestion.
   - and for XEmacs beta-tests.

Thanks to Klaus Berndl <klaus.berndl@sdm.de> for user defined PostScript prologue code suggestion, for odd/even printing suggestion and for ps-prologue-file enhancement.

Thanks to Ken'ichi Handa <handa@gnu.org> for multi-byte buffer handling.

Thanks to Matthew O Persico <Matthew.Persico@lazard.com> for line number on empty columns.

Thanks to Theodore Jump <tjump@cais.com> for adjust PostScript code order on last page.

Thanks to Roland Ducournau <ducour@lirmm.fr> for ps-print-control-characters variable documentation.

Thanks to Marcus G Daniels <marcus@cathcart.sysc.pdx.edu> for a better database font management.

Thanks to Martin Boyer <gamin@videotron.ca> for some ideas on putting one header per page over the columns and correct line numbers when printing a region.

Thanks to Steven L Baur <steve@miranova.com> for dynamic evaluation at print time of ps-lpr-switches.

Thanks to Kevin Rodgers <kevinr@ihs.com> for handling control characters
(his code was severely modified, but the main idea was kept).

Thanks to some suggestions on:
 * Face color map: Marco Melgazzi <marco@techie.com>
 * XEmacs compatibility: William J. Henney <will@astrosmo.unam.mx>
 * Check ps-paper-type: Sudhakar Frederick <sfrederi@asc.corp.mot.com>

Thanks to Jacques Duthen <duthen@cegelec-red.fr> (Jack) for version 3.4 I started from. [vinicius]

Thanks to Jim Thompson <?@?> for the 2.8 version I started from. [jack]

Thanks to Kevin Rodgers <kevinr@ihs.com> for adding support for color and the invisible property.

Thanks to Avishai Yacobi, avishaiy@mcil.comm.mot.com, for writing the initial port to Emacs 19. His code is no longer part of ps-print, but his work is still appreciated.

Thanks to Remi Houdaille and Michel Train <michel@metasoft.fdn.org> for adding underline support. Their code also is no longer part of ps-print, but their efforts are not forgotten.

Thanks also to all of you who mailed code to add features to ps-print; although I didn't use your code, I still appreciate your sharing it with me.

Thanks to all who mailed comments, encouragement, and criticism. Thanks also to all who responded to my survey; I had too many responses to reply to them all, but I greatly appreciate your interest.

Jim
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Defined variables (112)

Defined functions (130)

Defined faces (0)