Homepage: https://www.emacswiki.org/cgi-bin/wiki/ViniciusJoseLatorre
Author: Jacques Duthen (was, Jim Thompson (was, Kenichi Handa, Vinicius Jose Latorre
Print text from the buffer as PostScript
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
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:
(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 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' 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 "<> 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
--------------------------
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' 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 '( ))
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
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
`ps-print-region-function'
[vinicius] Vinicius Jose Latorre
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
Multi-byte buffer handling.
[vinicius] Vinicius Jose Latorre
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
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 for fixing face
background/foreground extraction.
Thanks to Friedrich Delgado Friedrichs for new label
printer page sizes.
Thanks to Michael Piotrowski for improving the DSC
compliance of the generated PostScript.
Thanks to Adam Doppelt for face mapping suggestion
for black/white PostScript printers.
Thanks to Toni Ronkko for line and paragraph spacing,
region to cut out when printing and footer suggestions.
Thanks to Pavel Janik ml for documentation correction.
Thanks to Corinne Ilvedson for line number font size
suggestion.
Thanks to Gord Wait for
`ps-user-defined-prologue' example setting for HP PostScript printer.
Thanks to Paul Furnanz for XEmacs compatibility
suggestion for `ps-postscript-code-directory' variable.
Thanks to David X Callaway for helping debugging PostScript
level 1 compatibility.
Thanks to Colin Marquardt 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 for user defined PostScript
prologue code suggestion, for odd/even printing suggestion and for
`ps-prologue-file' enhancement.
Thanks to Ken'ichi Handa for multi-byte buffer handling.
Thanks to Matthew O Persico for line number on
empty columns.
Thanks to Theodore Jump for adjust PostScript code order on
last page.
Thanks to Roland Ducournau for
`ps-print-control-characters' variable documentation.
Thanks to Marcus G Daniels for a better
database font management.
Thanks to Martin Boyer 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 for dynamic evaluation at
print time of `ps-lpr-switches'.
Thanks to Kevin Rodgers 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
* XEmacs compatibility: William J. Henney
* Check `ps-paper-type': Sudhakar Frederick
Thanks to Jacques Duthen (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 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 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
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;