Übersicht Letzte Änderungen Neuigkeiten Suchen ElispSektion KurzAnleitung Impressum

PsPrintPackage-22

This page describes package Lisp:ps-print-22.tar.gz, by ViniciusJoseLatorre.

See README file for installation instructions.

.:: v6.8.2 :: part of GNU Emacs 22 ::.
.:: depends on lpr.el :: mule ::.

Older Versions

Newer Versions

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 or XEmacs, 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 RET

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 RET

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 RET

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:

   (global-set-key 'f22 'ps-spool-buffer-with-faces) ;f22 is prsc
   (global-set-key '(shift f22) 'ps-spool-region-with-faces)
   (global-set-key '(control 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 95/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 PostScript.

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:

but also:

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’ 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’ is set to nil. But the latest ‘ps-selected-pages’ 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’ 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’ 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’ specifies how page matrix is filled on each sheet of paper. Following are the valid values for ‘ps-n-up-filling’ 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

The variable ‘ps-multibyte-buffer’ specifies the ps-print multi-byte buffer handling.

Valid values for ‘ps-multibyte-buffer’ are:

nil
This is the value to use the default settings which is by default for printing buffer with only ASCII and Latin characters. The default setting can be changed by setting the variable ‘ps-mule-font-info-database-default’ differently.
The initial value of this variable is ‘ps-mule-font-info-database-latin’ (see documentation).
non-latin-printer
This is the value to use when you have a japanese or korean PostScript printer and want to print buffer with ASCII, Latin-1, Japanese (JISX0208 and JISX0201-Kana) and Korean characters. At present, it was not tested the Korean characters printing.
If you have a korean PostScript printer, please, test it.
bdf-font
This is the value to use when you want to print buffer with BDF fonts. BDF fonts include both latin and non-latin fonts. BDF (Bitmap Distribution Format) is a format used for distributing X’s font source file. BDF fonts are included in intlfonts-1.2 which is a collection of X11 fonts for all characters supported by Emacs. In order to use this value, be sure to have installed intlfonts-1.2 and set the variable ‘bdf-directory-list’ appropriately (see ps-bdf.el for documentation of this variable).
bdf-font-except-latin
This is like ‘bdf-font’ except that it is used PostScript default fonts to print ASCII and Latin-1 characters. This is convenient when you want or need to use both latin and non-latin characters on the same buffer. See ‘ps-font-family’, ‘ps-header-font-family’ and ‘ps-font-info-database’.

Any other value is treated as nil.

The default is nil.

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’:

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’ 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:

      % 3 cm 20 cm moveto  10/Courier ReportFontInfo  showpage
      3 cm 20 cm moveto  10/Helvetica ReportFontInfo  showpage
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
      (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))
      (setq ps-font-family 'Helvetica)
      (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 a 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 .emacs 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@ig.com.br>

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’, ‘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@ig.com.br>

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@ig.com.br>

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

Although color printing will work in XEmacs 19.12, it doesn’t work well; in particular, bold or italic fonts don’t print in the right background color.

Invisible properties aren’t correctly ignored in XEmacs 19.12.

Automatic font-attribute detection doesn’t work well, especially with hilit19 and older versions of get-create-face. 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.

Automatic font-attribute detection doesn’t work with XEmacs 19.12 in tty mode; use the lists ‘ps-italic-faces’, ‘ps-bold-faces’ and ‘ps-underlined-faces’ instead.

Still too slow; could use some hand-optimization.

Faces are always treated as opaque.

Epoch, Lucid and Emacs 19 not supported. At all.

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 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 ColinMarquardt for:

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@m17n.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 KevinRodgers for handling control characters (his code was severely modified, but the main idea was kept).

Thanks to some suggestions on:

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 KevinRodgers 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

See Also


CategoryCode, CategoryPrinting