(defconst ps-print-version "4.1.4"
"ps-print.el, v 4.1.4 <99/02/19 vinicius>
Vinicius's last change version -- this file may have been edited as part of
Emacs without changes to the version number. When reporting bugs,
please also report the version of Emacs, if any, that ps-print was
distributed with.
Please send all bug fixes and enhancements to
Vinicius Jose Latorre <vinicius@cpqd.com.br>.
")
(unless (featurep 'lisp-float-type)
(error "`ps-print' requires floating point support"))
(eval-and-compile
(and (string< mule-version "4.0")
(progn
(defun set-buffer-multibyte (arg)
(setq enable-multibyte-characters arg))
(defun string-as-unibyte (arg) arg)
(defun string-as-multibyte (arg) arg)
(defun charset-after (&optional arg)
(char-charset (char-after arg))))))
(defgroup ps-print nil
"PostScript generator for Emacs 19"
:prefix "ps-"
:group 'wp)
(defgroup ps-print-horizontal nil
"Horizontal page layout"
:prefix "ps-"
:tag "Horizontal"
:group 'ps-print)
(defgroup ps-print-vertical nil
"Vertical page layout"
:prefix "ps-"
:tag "Vertical"
:group 'ps-print)
(defgroup ps-print-header nil
"Headers layout"
:prefix "ps-"
:tag "Header"
:group 'ps-print)
(defgroup ps-print-font nil
"Fonts customization"
:prefix "ps-"
:tag "Font"
:group 'ps-print)
(defgroup ps-print-color nil
"Color customization"
:prefix "ps-"
:tag "Color"
:group 'ps-print)
(defgroup ps-print-face nil
"Faces customization"
:prefix "ps-"
:tag "PS Faces"
:group 'ps-print
:group 'faces)
(defcustom ps-print-prologue-header nil
"*PostScript prologue header comments besides that ps-print generates.
`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\".
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 `ps-spool-duplex').
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"
:type '(choice string symbol (other :tag "nil" nil))
:group 'ps-print)
(defcustom ps-printer-name (and (boundp 'printer-name)
printer-name)
"*The name of a local printer for printing PostScript files.
On Unix-like systems, a string value should be a name understood by
lpr's -P option; a value of nil means use the value of `printer-name'
instead. Any other value will be ignored.
On MS-DOS and MS-Windows systems, a string value is taken as the name of
the printer device or port to which PostScript files are written,
provided `ps-lpr-command' is \"\". By default it is the same as
`printer-name'; typical non-default settings would be \"LPT1\" to
\"LPT3\" for parallel printers, or \"COM1\" to \"COM4\" or \"AUX\" for
serial printers, or \"//hostname/printer\" for a shared network printer.
You can also set it to a name of a file, in which case the output gets
appended to that file. \(Note that `ps-print' package already has
facilities for printing to a file, so you might as well use them instead
of changing the setting of this variable.\) If you want to silently
discard the printed output, set this to \"NUL\"."
:type '(choice (file :tag "Name")
(const :tag "Default" nil))
:group 'ps-print)
(defcustom ps-lpr-command lpr-command
"*Name of program for printing a PostScript file.
On MS-DOS and MS-Windows systems, if the value is an empty string then
Emacs will write directly to the printer port named by `ps-printer-name'.
The programs `print' and `nprint' (the standard print programs on Windows
NT and Novell Netware respectively) are handled specially, using
`ps-printer-name' as the destination for output; any other program is
treated like `lpr' except that an explicit filename is given as the last
argument."
:type 'string
:group 'ps-print)
(defcustom ps-lpr-switches lpr-switches
"*A list of extra switches to pass to `ps-lpr-command'."
:type '(repeat string)
:group 'ps-print)
(defcustom ps-print-region-function nil
"Function to call to print the region on a PostScript printer.
See definition of `ps-do-despool' for calling conventions."
:type 'function
:group 'ps-print)
(defcustom ps-page-dimensions-database
(list (list 'a4 (/ (* 72 21.0) 2.54) (/ (* 72 29.7) 2.54))
(list 'a3 (/ (* 72 29.7) 2.54) (/ (* 72 42.0) 2.54))
(list 'letter (* 72 8.5) (* 72 11.0))
(list 'legal (* 72 8.5) (* 72 14.0))
(list 'letter-small (* 72 7.68) (* 72 10.16))
(list 'tabloid (* 72 11.0) (* 72 17.0))
(list 'ledger (* 72 17.0) (* 72 11.0))
(list 'statement (* 72 5.5) (* 72 8.5))
(list 'executive (* 72 7.5) (* 72 10.0))
(list 'a4small (* 72 7.47) (* 72 10.85))
(list 'b4 (* 72 10.125) (* 72 14.33))
(list 'b5 (* 72 7.16) (* 72 10.125)))
"*List associating a symbolic paper type to its width and height.
see `ps-paper-type'."
:type '(repeat (list :tag "Paper Type"
(symbol :tag "Name")
(number :tag "Width")
(number :tag "Height")))
:group 'ps-print)
(defcustom ps-paper-type 'letter
"*Specifies the size of paper to format for.
Should be one of the paper types defined in `ps-page-dimensions-database', for
example `letter', `legal' or `a4'."
:type '(symbol :validate (lambda (wid)
(if (assq (widget-value wid)
ps-page-dimensions-database)
nil
(widget-put wid :error "Unknown paper size")
wid)))
:group 'ps-print)
(defcustom ps-landscape-mode nil
"*Non-nil means print in landscape mode."
:type 'boolean
:group 'ps-print)
(defcustom ps-print-control-characters 'control-8-bit
"*Specifies the 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 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."
:type '(choice (const 8-bit) (const control-8-bit)
(const control) (other :tag "nil" nil))
:group 'ps-print)
(defcustom ps-number-of-columns (if ps-landscape-mode 2 1)
"*Specifies the number of columns"
:type 'number
:group 'ps-print)
(defcustom ps-zebra-stripes nil
"*Non-nil means print zebra stripes.
See also documentation for `ps-zebra-stripe-height'."
:type 'boolean
:group 'ps-print)
(defcustom ps-zebra-stripe-height 3
"*Number of zebra stripe lines.
See also documentation for `ps-zebra-stripes'."
:type 'number
:group 'ps-print)
(defcustom ps-line-number nil
"*Non-nil means print line number."
:type 'boolean
:group 'ps-print)
(defcustom ps-print-background-image nil
"*EPS image list to be printed on background.
The elements are:
(FILENAME X Y XSCALE YSCALE ROTATION PAGES...)
FILENAME is a file name which contains an EPS image or some PostScript
programming like EPS.
FILENAME is ignored, if it doesn't exist or is read protected.
X and Y are relative positions on paper to put the image.
If X and Y are nil, the image is centralized on paper.
XSCALE and YSCALE are scale factor to be applied to image before printing.
If XSCALE and YSCALE are nil, the original size is used.
ROTATION is the image rotation angle; if nil, the default is 0.
PAGES designates the page to print background image.
PAGES may be a number or a cons cell (FROM . TO) designating FROM page
to TO page.
If PAGES is nil, print background image on all pages.
X, Y, XSCALE, YSCALE and ROTATION may be a floating point number,
an integer number or a string. If it is a string, the string should contain
PostScript programming that returns a float or integer value.
For example, if you wish to print an EPS image on all pages do:
'((\"~/images/EPS-image.ps\"))"
:type '(repeat (list file
(choice :tag "X" number string (const nil))
(choice :tag "Y" number string (const nil))
(choice :tag "X Scale" number string (const nil))
(choice :tag "Y Scale" number string (const nil))
(choice :tag "Rotation" number string (const nil))
(repeat :tag "Pages" :inline t
(radio integer
(cons :tag "Range"
(integer :tag "From")
(integer :tag "To"))))))
:group 'ps-print)
(defcustom ps-print-background-text nil
"*Text list to be printed on background.
The elements are:
(STRING X Y FONT FONTSIZE GRAY ROTATION PAGES...)
STRING is the text to be printed on background.
X and Y are positions on paper to put the text.
If X and Y are nil, the text is positioned at lower left corner.
FONT is a font name to be used on printing the text.
If nil, \"Times-Roman\" is used.
FONTSIZE is font size to be used, if nil, 200 is used.
GRAY is the text gray factor (should be very light like 0.8).
If nil, the default is 0.85.
ROTATION is the text rotation angle; if nil, the angle is given by
the diagonal from lower left corner to upper right corner.
PAGES designates the page to print background text.
PAGES may be a number or a cons cell (FROM . TO) designating FROM page
to TO page.
If PAGES is nil, print background text on all pages.
X, Y, FONTSIZE, GRAY and ROTATION may be a floating point number,
an integer number or a string. If it is a string, the string should contain
PostScript programming that returns a float or integer value.
For example, if you wish to print text \"Preliminary\" on all pages do:
'((\"Preliminary\"))"
:type '(repeat (list string
(choice :tag "X" number string (const nil))
(choice :tag "Y" number string (const nil))
(choice :tag "Font" string (const nil))
(choice :tag "Fontsize" number string (const nil))
(choice :tag "Gray" number string (const nil))
(choice :tag "Rotation" number string (const nil))
(repeat :tag "Pages" :inline t
(radio integer
(cons :tag "Range"
(integer :tag "From")
(integer :tag "To"))))))
:group 'ps-print)
(defcustom ps-left-margin (/ (* 72 2.0) 2.54) "*Left margin in points (1/72 inch)."
:type 'number
:group 'ps-print-horizontal)
(defcustom ps-right-margin (/ (* 72 2.0) 2.54) "*Right margin in points (1/72 inch)."
:type 'number
:group 'ps-print-horizontal)
(defcustom ps-inter-column (/ (* 72 2.0) 2.54) "*Horizontal space between columns in points (1/72 inch)."
:type 'number
:group 'ps-print-horizontal)
(defcustom ps-bottom-margin (/ (* 72 1.5) 2.54) "*Bottom margin in points (1/72 inch)."
:type 'number
:group 'ps-print-vertical)
(defcustom ps-top-margin (/ (* 72 1.5) 2.54) "*Top margin in points (1/72 inch)."
:type 'number
:group 'ps-print-vertical)
(defcustom ps-header-offset (/ (* 72 1.0) 2.54) "*Vertical space in points (1/72 inch) between the main text and the header."
:type 'number
:group 'ps-print-vertical)
(defcustom ps-header-line-pad 0.15
"*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."
:type 'number
:group 'ps-print-vertical)
(defcustom ps-print-header t
"*Non-nil means print a header at the top of each page.
By default, the header displays the buffer name, page number, and, if
the buffer is visiting a file, the file's directory. Headers are
customizable by changing variables `ps-left-header' and
`ps-right-header'."
:type 'boolean
:group 'ps-print-header)
(defcustom ps-print-only-one-header nil
"*Non-nil means print only one header at the top of each page.
This is useful when printing more than one column, so it is possible
to have only one header over all columns or one header per column.
See also `ps-print-header'."
:type 'boolean
:group 'ps-print-header)
(defcustom ps-print-header-frame t
"*Non-nil means draw a gaudy frame around the header."
:type 'boolean
:group 'ps-print-header)
(defcustom ps-header-lines 2
"*Number of lines to display in page header, when generating PostScript."
:type 'integer
:group 'ps-print-header)
(make-variable-buffer-local 'ps-header-lines)
(defcustom ps-show-n-of-n t
"*Non-nil means show page numbers as N/M, meaning page N of M.
NOTE: page numbers are displayed as part of headers,
see variable `ps-print-headers'."
:type 'boolean
:group 'ps-print-header)
(defcustom ps-spool-duplex nil "*Non-nil indicates spooling is for a two-sided printer.
For a duplex printer, the `ps-spool-*' commands will insert blank pages
as needed between print jobs so that the next buffer printed will
start on the right page. Also, if headers are turned on, the headers
will be reversed on duplex printers so that the page numbers fall to
the left on even-numbered pages."
:type 'boolean
:group 'ps-print-header)
(defcustom ps-font-info-database
'((Courier (fonts (normal . "Courier")
(bold . "Courier-Bold")
(italic . "Courier-Oblique")
(bold-italic . "Courier-BoldOblique"))
(size . 10.0)
(line-height . 10.55)
(space-width . 6.0)
(avg-char-width . 6.0))
(Helvetica (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))
(Times
(fonts (normal . "Times-Roman")
(bold . "Times-Bold")
(italic . "Times-Italic")
(bold-italic . "Times-BoldItalic"))
(size . 10.0)
(line-height . 11.0)
(space-width . 2.5)
(avg-char-width . 4.71432))
(Palatino
(fonts (normal . "Palatino-Roman")
(bold . "Palatino-Bold")
(italic . "Palatino-Italic")
(bold-italic . "Palatino-BoldItalic"))
(size . 10.0)
(line-height . 12.1)
(space-width . 2.5)
(avg-char-width . 5.08676))
(Helvetica-Narrow
(fonts (normal . "Helvetica-Narrow")
(bold . "Helvetica-Narrow-Bold")
(italic . "Helvetica-Narrow-Oblique")
(bold-italic . "Helvetica-Narrow-BoldOblique"))
(size . 10.0)
(line-height . 11.56)
(space-width . 2.2796)
(avg-char-width . 4.17579))
(NewCenturySchlbk
(fonts (normal . "NewCenturySchlbk-Roman")
(bold . "NewCenturySchlbk-Bold")
(italic . "NewCenturySchlbk-Italic")
(bold-italic . "NewCenturySchlbk-BoldItalic"))
(size . 10.0)
(line-height . 12.15)
(space-width . 2.78)
(avg-char-width . 5.31162))
(AvantGarde-Book
(fonts (normal . "AvantGarde-Book")
(italic . "AvantGarde-BookOblique"))
(size . 10.0)
(line-height . 11.77)
(space-width . 2.77)
(avg-char-width . 5.45189))
(AvantGarde-Demi
(fonts (normal . "AvantGarde-Demi")
(italic . "AvantGarde-DemiOblique"))
(size . 10.0)
(line-height . 12.72)
(space-width . 2.8)
(avg-char-width . 5.51351))
(Bookman-Demi
(fonts (normal . "Bookman-Demi")
(italic . "Bookman-DemiItalic"))
(size . 10.0)
(line-height . 11.77)
(space-width . 3.4)
(avg-char-width . 6.05946))
(Bookman-Light
(fonts (normal . "Bookman-Light")
(italic . "Bookman-LightItalic"))
(size . 10.0)
(line-height . 11.79)
(space-width . 3.2)
(avg-char-width . 5.67027))
(Symbol
(fonts (normal . "Symbol"))
(size . 10.0)
(line-height . 13.03)
(space-width . 2.5)
(avg-char-width . 3.24324))
(Zapf-Dingbats
(fonts (normal . "Zapf-Dingbats"))
(size . 10.0)
(line-height . 9.63)
(space-width . 2.78)
(avg-char-width . 2.78))
(Zapf-Chancery-MediumItalic
(fonts (normal . "Zapf-Chancery-MediumItalic"))
(size . 10.0)
(line-height . 11.45)
(space-width . 2.2)
(avg-char-width . 4.10811))
)
"*Font info database: font family (the key), name, bold, italic, bold-italic,
reference size, line height, space width, average character width.
To get the info for another specific font (say Helvetica), do the following:
- create a new buffer
- generate the PostScript image to a file (C-u M-x ps-print-buffer)
- open this file and delete the leading `%' (which is the PostScript
comment character) from the line
`% 3 cm 20 cm moveto 10 /Courier ReportFontInfo showpage'
to get the line
`3 cm 20 cm moveto 10 /Helvetica ReportFontInfo showpage'
- add the values to `ps-font-info-database'.
You can get all the fonts of YOUR printer using `ReportAllFontInfo'."
:type '(repeat (list :tag "Font Definition"
(symbol :tag "Font Family")
(cons :format "%v"
(const :format "" fonts)
(repeat :tag "Faces"
(cons (choice (const normal)
(const bold)
(const italic)
(const bold-italic)
(symbol :tag "Face"))
(string :tag "Font Name"))))
(cons :format "%v"
(const :format "" size)
(number :tag "Reference Size"))
(cons :format "%v"
(const :format "" line-height)
(number :tag "Line Height"))
(cons :format "%v"
(const :format "" space-width)
(number :tag "Space Width"))
(cons :format "%v"
(const :format "" avg-char-width)
(number :tag "Average Character Width"))))
:group 'ps-print-font)
(defcustom ps-font-family 'Courier
"*Font family name for ordinary text, when generating PostScript."
:type 'symbol
:group 'ps-print-font)
(defcustom ps-font-size '(7 . 8.5)
"*Font size, in points, for ordinary text, when generating PostScript."
:type '(choice (number :tag "Text Size")
(cons :tag "Landscape/Portrait"
(number :tag "Landscape Text Size")
(number :tag "Portrait Text Size")))
:group 'ps-print-font)
(defcustom ps-header-font-family 'Helvetica
"*Font family name for text in the header, when generating PostScript."
:type 'symbol
:group 'ps-print-font)
(defcustom ps-header-font-size '(10 . 12)
"*Font size, in points, for text in the header, when generating PostScript."
:type '(choice (number :tag "Header Size")
(cons :tag "Landscape/Portrait"
(number :tag "Landscape Header Size")
(number :tag "Portrait Header Size")))
:group 'ps-print-font)
(defcustom ps-header-title-font-size '(12 . 14)
"*Font size, in points, for the top line of text in header, in PostScript."
:type '(choice (number :tag "Header Title Size")
(cons :tag "Landscape/Portrait"
(number :tag "Landscape Header Title Size")
(number :tag "Portrait Header Title Size")))
:group 'ps-print-font)
(defcustom ps-print-color-p (or (fboundp 'x-color-values) (fboundp 'color-instance-rgb-components))
"*If non-nil, print the buffer's text in color."
:type 'boolean
:group 'ps-print-color)
(defcustom ps-default-fg '(0.0 0.0 0.0)
"*RGB values of the default foreground color. Defaults to black."
:type '(list (number :tag "Red") (number :tag "Green") (number :tag "Blue"))
:group 'ps-print-color)
(defcustom ps-default-bg '(1.0 1.0 1.0)
"*RGB values of the default background color. Defaults to white."
:type '(list (number :tag "Red") (number :tag "Green") (number :tag "Blue"))
:group 'ps-print-color)
(defcustom ps-auto-font-detect t
"*Non-nil means automatically detect bold/italic face attributes.
If nil, we rely solely on the lists `ps-bold-faces', `ps-italic-faces',
and `ps-underlined-faces'."
:type 'boolean
:group 'ps-print-font)
(defcustom ps-bold-faces
(unless ps-print-color-p
'(font-lock-function-name-face
font-lock-builtin-face
font-lock-variable-name-face
font-lock-keyword-face
font-lock-warning-face))
"*A list of the \(non-bold\) faces that should be printed in bold font.
This applies to generating PostScript."
:type '(repeat face)
:group 'ps-print-face)
(defcustom ps-italic-faces
(unless ps-print-color-p
'(font-lock-variable-name-face
font-lock-type-face
font-lock-string-face
font-lock-comment-face
font-lock-warning-face))
"*A list of the \(non-italic\) faces that should be printed in italic font.
This applies to generating PostScript."
:type '(repeat face)
:group 'ps-print-face)
(defcustom ps-underlined-faces
(unless ps-print-color-p
'(font-lock-function-name-face
font-lock-constant-face
font-lock-warning-face))
"*A list of the \(non-underlined\) faces that should be printed underlined.
This applies to generating PostScript."
:type '(repeat face)
:group 'ps-print-face)
(defcustom ps-left-header
(list 'ps-get-buffer-name 'ps-header-dirpart)
"*The items to display (each on a line) on the left part of the page header.
This applies to generating PostScript.
The value should be a list of strings and symbols, each representing an
entry in the PostScript array HeaderLinesLeft.
Strings are inserted unchanged into the array; those representing
PostScript string literals should be delimited with PostScript string
delimiters '(' and ')'.
For symbols with bound functions, the function is called and should
return a string to be inserted into the array. For symbols with bound
values, the value should be a string to be inserted into the array.
In either case, function or variable, the string value has PostScript
string delimiters added to it."
:type '(repeat (choice string symbol))
:group 'ps-print-header)
(make-variable-buffer-local 'ps-left-header)
(defcustom ps-right-header
(list "/pagenumberstring load" 'time-stamp-mon-dd-yyyy 'time-stamp-hh:mm:ss)
"*The items to display (each on a line) on the right part of the page header.
This applies to generating PostScript.
See the variable `ps-left-header' for a description of the format of
this variable."
:type '(repeat (choice string symbol))
:group 'ps-print-header)
(make-variable-buffer-local 'ps-right-header)
(defcustom ps-razzle-dazzle t
"*Non-nil means report progress while formatting buffer."
:type 'boolean
:group 'ps-print)
(defcustom ps-adobe-tag "%!PS-Adobe-3.0\n"
"*Contains the header line identifying the output as PostScript.
By default, `ps-adobe-tag' contains the standard identifier. Some
printers require slightly different versions of this line."
:type 'string
:group 'ps-print)
(defcustom ps-build-face-reference t
"*Non-nil means build the reference face lists.
ps-print sets this value to nil after it builds its internal reference
lists of bold and italic faces. By settings its value back to t, you
can force ps-print to rebuild the lists the next time you invoke one
of the ...-with-faces commands.
You should set this value back to t after you change the attributes of
any face, or create new faces. Most users shouldn't have to worry
about its setting, though."
:type 'boolean
:group 'ps-print-face)
(defcustom ps-always-build-face-reference nil
"*Non-nil means always rebuild the reference face lists.
If this variable is non-nil, ps-print will rebuild its internal
reference lists of bold and italic faces *every* time one of the
...-with-faces commands is called. Most users shouldn't need to set this
variable."
:type 'boolean
:group 'ps-print-face)
(defun ps-print-buffer (&optional filename)
"Generate and print a PostScript image of the buffer.
Interactively, when you use a prefix argument (C-u), the command
prompts the user for a file name, and saves the PostScript image
in that file instead of sending it to the printer.
Noninteractively, the argument FILENAME is treated as follows: if it
is nil, send the image to the printer. If FILENAME is a string, save
the PostScript image in a file with that name."
(interactive (list (ps-print-preprint current-prefix-arg)))
(ps-print-without-faces (point-min) (point-max) filename))
(defun ps-print-buffer-with-faces (&optional filename)
"Generate and print a PostScript image of the buffer.
Like `ps-print-buffer', but includes font, color, and underline
information in the generated image. This command works only if you
are using a window system, so it has a way to determine color values."
(interactive (list (ps-print-preprint current-prefix-arg)))
(ps-print-with-faces (point-min) (point-max) filename))
(defun ps-print-region (from to &optional filename)
"Generate and print a PostScript image of the region.
Like `ps-print-buffer', but prints just the current region."
(interactive (list (point) (mark) (ps-print-preprint current-prefix-arg)))
(ps-print-without-faces from to filename t))
(defun ps-print-region-with-faces (from to &optional filename)
"Generate and print a PostScript image of the region.
Like `ps-print-region', but includes font, color, and underline
information in the generated image. This command works only if you
are using a window system, so it has a way to determine color values."
(interactive (list (point) (mark) (ps-print-preprint current-prefix-arg)))
(ps-print-with-faces from to filename t))
(defun ps-spool-buffer ()
"Generate and spool a PostScript image of the buffer.
Like `ps-print-buffer' except that the PostScript image is saved in a
local buffer to be sent to the printer later.
Use the command `ps-despool' to send the spooled images to the printer."
(interactive)
(ps-spool-without-faces (point-min) (point-max)))
(defun ps-spool-buffer-with-faces ()
"Generate and spool a PostScript image of the buffer.
Like `ps-spool-buffer', but includes font, color, and underline
information in the generated image. This command works only if you
are using a window system, so it has a way to determine color values.
Use the command `ps-despool' to send the spooled images to the printer."
(interactive)
(ps-spool-with-faces (point-min) (point-max)))
(defun ps-spool-region (from to)
"Generate a PostScript image of the region and spool locally.
Like `ps-spool-buffer', but spools just the current region.
Use the command `ps-despool' to send the spooled images to the printer."
(interactive "r")
(ps-spool-without-faces from to t))
(defun ps-spool-region-with-faces (from to)
"Generate a PostScript image of the region and spool locally.
Like `ps-spool-region', but includes font, color, and underline
information in the generated image. This command works only if you
are using a window system, so it has a way to determine color values.
Use the command `ps-despool' to send the spooled images to the printer."
(interactive "r")
(ps-spool-with-faces from to t))
(defun ps-despool (&optional filename)
"Send the spooled PostScript to the printer.
Interactively, when you use a prefix argument (C-u), the command
prompts the user for a file name, and saves the spooled PostScript
image in that file instead of sending it to the printer.
Noninteractively, the argument FILENAME is treated as follows: if it
is nil, send the image to the printer. If FILENAME is a string, save
the PostScript image in a file with that name."
(interactive (list (ps-print-preprint current-prefix-arg)))
(ps-do-despool filename))
(defun ps-line-lengths ()
"Display the correspondence between a line length and a font size,
using the current ps-print setup.
Try: pr -t file | awk '{printf \"%3d %s\n\", length($0), $0}' | sort -r | head"
(interactive)
(ps-line-lengths-internal))
(defun ps-nb-pages-buffer (nb-lines)
"Display number of pages to print this buffer, for various font heights.
The table depends on the current ps-print setup."
(interactive (list (count-lines (point-min) (point-max))))
(ps-nb-pages nb-lines))
(defun ps-nb-pages-region (nb-lines)
"Display number of pages to print the region, for various font heights.
The table depends on the current ps-print setup."
(interactive (list (count-lines (mark) (point))))
(ps-nb-pages nb-lines))
(defun ps-setup ()
"Return the current PostScript-generation setup."
(format
"
\(setq ps-print-color-p %s
ps-lpr-command %S
ps-lpr-switches %s
ps-printer-name %S
ps-paper-type %s
ps-landscape-mode %s
ps-number-of-columns %s
ps-zebra-stripes %s
ps-zebra-stripe-height %s
ps-line-number %s
ps-print-control-characters %s
ps-print-background-image %s
ps-print-background-text %s
ps-print-prologue-header %s
ps-left-margin %s
ps-right-margin %s
ps-inter-column %s
ps-bottom-margin %s
ps-top-margin %s
ps-header-offset %s
ps-header-line-pad %s
ps-print-header %s
ps-print-only-one-header %s
ps-print-header-frame %s
ps-header-lines %s
ps-show-n-of-n %s
ps-spool-duplex %s
ps-multibyte-buffer %s
ps-font-family %s
ps-font-size %s
ps-header-font-family %s
ps-header-font-size %s
ps-header-title-font-size %s)
"
ps-print-color-p
ps-lpr-command
(ps-print-quote ps-lpr-switches)
ps-printer-name
(ps-print-quote ps-paper-type)
ps-landscape-mode
ps-number-of-columns
ps-zebra-stripes
ps-zebra-stripe-height
ps-line-number
(ps-print-quote ps-print-control-characters)
(ps-print-quote ps-print-background-image)
(ps-print-quote ps-print-background-text)
(ps-print-quote ps-print-prologue-header)
ps-left-margin
ps-right-margin
ps-inter-column
ps-bottom-margin
ps-top-margin
ps-header-offset
ps-header-line-pad
ps-print-header
ps-print-only-one-header
ps-print-header-frame
ps-header-lines
ps-show-n-of-n
ps-spool-duplex
(ps-print-quote ps-multibyte-buffer) (ps-print-quote ps-font-family)
(ps-print-quote ps-font-size)
(ps-print-quote ps-header-font-family)
(ps-print-quote ps-header-font-size)
(ps-print-quote ps-header-title-font-size)))
(defun ps-print-quote (sym)
(cond ((null sym)
nil)
((or (symbolp sym) (listp sym))
(format "'%S" sym))
((stringp sym)
(format "%S" sym))
(t
sym)))
(defvar ps-print-emacs-type
(cond ((string-match "XEmacs" emacs-version) 'xemacs)
((string-match "Lucid" emacs-version) 'lucid)
((string-match "Epoch" emacs-version) 'epoch)
(t 'emacs)))
(if (or (eq ps-print-emacs-type 'lucid)
(eq ps-print-emacs-type 'xemacs))
(if (< emacs-minor-version 12)
(setq ps-print-color-p nil))
(require 'faces))
(cond ((and (eq ps-print-emacs-type 'xemacs)
(>= emacs-minor-version 12)) (defun ps-color-device ()
(eq (device-class) 'color))
)
(t (defun ps-color-device ()
t)
))
(require 'time-stamp)
(defvar ps-print-prologue-1
"% ISOLatin1Encoding stolen from ps_init.ps in GhostScript 2.6.1.4:
/ISOLatin1Encoding where { pop } {
% -- The ISO Latin-1 encoding vector isn't known, so define it.
% -- The first half is the same as the standard encoding,
% -- except for minus instead of hyphen at code 055.
/ISOLatin1Encoding
StandardEncoding 0 45 getinterval aload pop
/minus
StandardEncoding 46 82 getinterval aload pop
%*** NOTE: the following are missing in the Adobe documentation,
%*** but appear in the displayed table:
%*** macron at 0225, dieresis at 0230, cedilla at 0233, space at 0240.
% 0200 (128)
/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
/dotlessi /grave /acute /circumflex /tilde /macron /breve /dotaccent
/dieresis /.notdef /ring /cedilla /.notdef /hungarumlaut /ogonek /caron
% 0240 (160)
/space /exclamdown /cent /sterling
/currency /yen /brokenbar /section
/dieresis /copyright /ordfeminine /guillemotleft
/logicalnot /hyphen /registered /macron
/degree /plusminus /twosuperior /threesuperior
/acute /mu /paragraph /periodcentered
/cedilla /onesuperior /ordmasculine /guillemotright
/onequarter /onehalf /threequarters /questiondown
% 0300 (192)
/Agrave /Aacute /Acircumflex /Atilde
/Adieresis /Aring /AE /Ccedilla
/Egrave /Eacute /Ecircumflex /Edieresis
/Igrave /Iacute /Icircumflex /Idieresis
/Eth /Ntilde /Ograve /Oacute
/Ocircumflex /Otilde /Odieresis /multiply
/Oslash /Ugrave /Uacute /Ucircumflex
/Udieresis /Yacute /Thorn /germandbls
% 0340 (224)
/agrave /aacute /acircumflex /atilde
/adieresis /aring /ae /ccedilla
/egrave /eacute /ecircumflex /edieresis
/igrave /iacute /icircumflex /idieresis
/eth /ntilde /ograve /oacute
/ocircumflex /otilde /odieresis /divide
/oslash /ugrave /uacute /ucircumflex
/udieresis /yacute /thorn /ydieresis
256 packedarray def
} ifelse
/reencodeFontISO { %def
dup
length 12 add dict % Make a new font (a new dict the same size
% as the old one) with room for our new symbols.
begin % Make the new font the current dictionary.
{ 1 index /FID ne
{ def } { pop pop } ifelse
} forall % Copy each of the symbols from the old dictionary
% to the new one except for the font ID.
currentdict /FontType get 0 ne {
/Encoding ISOLatin1Encoding def % Override the encoding with
% the ISOLatin1 encoding.
} if
% Use the font's bounding box to determine the ascent, descent,
% and overall height; don't forget that these values have to be
% transformed using the font's matrix.
% ^ (x2 y2)
% | |
% | v
% | +----+ - -
% | | | ^
% | | | | Ascent (usually > 0)
% | | | |
% (0 0) -> +--+----+-------->
% | | |
% | | v Descent (usually < 0)
% (x1 y1) --> +----+ - -
currentdict /FontType get 0 ne {
/FontBBox load aload pop % -- x1 y1 x2 y2
FontMatrix transform /Ascent exch def pop
FontMatrix transform /Descent exch def pop
} {
/PrimaryFont FDepVector 0 get def
PrimaryFont /FontBBox get aload pop
PrimaryFont /FontMatrix get transform /Ascent exch def pop
PrimaryFont /FontMatrix get transform /Descent exch def pop
} ifelse
/FontHeight Ascent Descent sub def % use `sub' because descent < 0
% Define these in case they're not in the FontInfo
% (also, here they're easier to get to).
/UnderlinePosition Descent 0.70 mul def
/OverlinePosition Descent UnderlinePosition sub Ascent add def
/StrikeoutPosition Ascent 0.30 mul def
/LineThickness FontHeight 0.05 mul def
/Xshadow FontHeight 0.08 mul def
/Yshadow FontHeight -0.09 mul def
/SpaceBackground Descent neg UnderlinePosition add def
/XBox Descent neg def
/YBox LineThickness 0.7 mul def
currentdict % Leave the new font on the stack
end % Stop using the font as the current dictionary.
definefont % Put the font into the font dictionary
pop % Discard the returned font.
} bind def
/DefFont { % Font definition
findfont exch scalefont reencodeFontISO
} def
/F { % Font selection
findfont
dup /Ascent get /Ascent exch def
dup /Descent get /Descent exch def
dup /FontHeight get /FontHeight exch def
dup /UnderlinePosition get /UnderlinePosition exch def
dup /OverlinePosition get /OverlinePosition exch def
dup /StrikeoutPosition get /StrikeoutPosition exch def
dup /LineThickness get /LineThickness exch def
dup /Xshadow get /Xshadow exch def
dup /Yshadow get /Yshadow exch def
dup /SpaceBackground get /SpaceBackground exch def
dup /XBox get /XBox exch def
dup /YBox get /YBox exch def
setfont
} def
/FG /setrgbcolor load def
/bg false def
/BG {
dup /bg exch def
{mark 4 1 roll ]}
{[ 1.0 1.0 1.0 ]}
ifelse
/bgcolor exch def
} def
% B width C
% +-----------+
% | Ascent (usually > 0)
% A + +
% | Descent (usually < 0)
% +-----------+
% E width D
/dobackground { % width --
currentpoint % -- width x y
gsave
newpath
moveto % A (x y)
0 Ascent rmoveto % B
dup 0 rlineto % C
0 Descent Ascent sub rlineto % D
neg 0 rlineto % E
closepath
bgcolor aload pop setrgbcolor
fill
grestore
} def
/eolbg { % dobackground until right margin
PrintWidth % -- x-eol
currentpoint pop % -- cur-x
sub % -- width until eol
dobackground
} def
/PLN {PrintLineNumber {doLineNumber}if} def
/SL { % Soft Linefeed
bg { eolbg } if
0 currentpoint exch pop LineHeight sub moveto
} def
/HL {SL PLN} def % Hard Linefeed
% Some debug
/dcp { currentpoint exch 40 string cvs print (, ) print = } def
/dp { print 2 copy exch 40 string cvs print (, ) print = } def
/W {
( ) stringwidth % Get the width of a space in the current font.
pop % Discard the Y component.
mul % Multiply the width of a space
% by the number of spaces to plot
bg { dup dobackground } if
0 rmoveto
} def
/Effect 0 def
/EF {/Effect exch def} def
% stack: string |- --
% effect: 1 - underline 2 - strikeout 4 - overline
% 8 - shadow 16 - box 32 - outline
/S {
/xx currentpoint dup Descent add /yy exch def
Ascent add /YY exch def def
dup stringwidth pop xx add /XX exch def
Effect 8 and 0 ne {
/yy yy Yshadow add def
/XX XX Xshadow add def
} if
bg {
true
Effect 16 and 0 ne
{SpaceBackground doBox}
{xx yy XX YY doRect}
ifelse
} if % background
Effect 16 and 0 ne {false 0 doBox}if % box
Effect 8 and 0 ne {dup doShadow}if % shadow
Effect 32 and 0 ne
{true doOutline} % outline
{show} % normal text
ifelse
Effect 1 and 0 ne {UnderlinePosition Hline}if % underline
Effect 2 and 0 ne {StrikeoutPosition Hline}if % strikeout
Effect 4 and 0 ne {OverlinePosition Hline}if % overline
} bind def
% stack: position |- --
/Hline {
currentpoint exch pop add dup
gsave
newpath
xx exch moveto
XX exch lineto
closepath
LineThickness setlinewidth stroke
grestore
} bind def
% stack: fill-or-not delta |- --
/doBox {
/dd exch def
xx XBox sub dd sub yy YBox sub dd sub
XX XBox add dd add YY YBox add dd add
doRect
} bind def
% stack: fill-or-not lower-x lower-y upper-x upper-y |- --
/doRect {
/rYY exch def
/rXX exch def
/ryy exch def
/rxx exch def
gsave
newpath
rXX rYY moveto
rxx rYY lineto
rxx ryy lineto
rXX ryy lineto
closepath
% top of stack: fill-or-not
{FillBgColor}
{LineThickness setlinewidth stroke}
ifelse
grestore
} bind def
% stack: string |- --
/doShadow {
gsave
Xshadow Yshadow rmoveto
false doOutline
grestore
} bind def
/st 1 string def
% stack: string fill-or-not |- --
/doOutline {
/-fillp- exch def
/-ox- currentpoint /-oy- exch def def
gsave
LineThickness setlinewidth
{
st 0 3 -1 roll put
st dup true charpath
-fillp- {gsave FillBgColor grestore}if
stroke stringwidth
-oy- add /-oy- exch def
-ox- add /-ox- exch def
-ox- -oy- moveto
} forall
grestore
-ox- -oy- moveto
} bind def
% stack: --
/FillBgColor {bgcolor aload pop setrgbcolor fill} bind def
/L0 6 /Times-Italic DefFont
% stack: --
/doLineNumber {
/LineNumber where
{
pop
currentfont
gsave
0.0 0.0 0.0 setrgbcolor
/L0 findfont setfont
LineNumber Lines ge
{(end )}
{LineNumber 6 string cvs ( ) strcat}
ifelse
dup stringwidth pop neg 0 rmoveto
show
grestore
setfont
/LineNumber LineNumber 1 add def
} if
} def
% stack: --
/printZebra {
gsave
0.985 setgray
/double-zebra ZebraHeight ZebraHeight add def
/yiter double-zebra LineHeight mul neg def
/xiter PrintWidth InterColumn add def
NumberOfColumns {LinesPerColumn doColumnZebra xiter 0 rmoveto}repeat
grestore
} def
% stack: lines-per-column |- --
/doColumnZebra {
gsave
dup double-zebra idiv {ZebraHeight doZebra 0 yiter rmoveto}repeat
double-zebra mod
dup 0 le {pop}{dup ZebraHeight gt {pop ZebraHeight}if doZebra}ifelse
grestore
} def
% stack: zebra-height (in lines) |- --
/doZebra {
/zh exch 0.05 sub LineHeight mul def
gsave
0 LineHeight 0.65 mul rmoveto
PrintWidth 0 rlineto
0 zh neg rlineto
PrintWidth neg 0 rlineto
0 zh rlineto
fill
grestore
} def
% tx ty rotation xscale yscale xpos ypos BeginBackImage
/BeginBackImage {
/-save-image- save def
/showpage {}def
translate
scale
rotate
translate
} def
/EndBackImage {
-save-image- restore
} def
% string fontsize fontname rotation gray xpos ypos ShowBackText
/ShowBackText {
gsave
translate
setgray
rotate
findfont exch dup /-offset- exch -0.25 mul def scalefont setfont
0 -offset- moveto
/-saveLineThickness- LineThickness def
/LineThickness 1 def
false doOutline
/LineThickness -saveLineThickness- def
grestore
} def
/BeginDoc {
% ---- Remember space width of the normal text font `f0'.
/SpaceWidth /f0 findfont setfont ( ) stringwidth pop def
% ---- save the state of the document (useful for ghostscript!)
/docState save def
% ---- [jack] Kludge: my ghostscript window is 21x27.7 instead of 21x29.7
/JackGhostscript where {pop 1 27.7 29.7 div scale}if
% ---- [andrewi] set PageSize based on chosen dimensions
% /setpagedevice where {
% pop
% 1 dict dup
% /PageSize [ PrintPageWidth LeftMargin add RightMargin add
% LandscapePageHeight ] put
% setpagedevice
% }{
LandscapeMode {
% ---- translate to bottom-right corner of Portrait page
LandscapePageHeight 0 translate
90 rotate
}if
% }ifelse
/ColumnWidth PrintWidth InterColumn add def
% ---- translate to lower left corner of TEXT
LeftMargin BottomMargin translate
% ---- define where printing will start
/f0 F % this installs Ascent
/PrintStartY PrintHeight Ascent sub def
/ColumnIndex 1 def
} def
/EndDoc {
% ---- on last page but not last column, spit out the page
ColumnIndex 1 eq not { showpage } if
% ---- restore the state of the document (useful for ghostscript!)
docState restore
} def
/BeginDSCPage {
% ---- when 1st column, save the state of the page
ColumnIndex 1 eq { /pageState save def } if
% ---- save the state of the column
/columnState save def
} def
/PrintHeaderWidth PrintOnlyOneHeader{PrintPageWidth}{PrintWidth}ifelse def
/BeginPage {
% ---- when 1st column, print all background effects
ColumnIndex 1 eq {
0 PrintStartY moveto % move to where printing will start
Zebra {printZebra}if
printGlobalBackground
printLocalBackground
} if
PrintHeader {
PrintOnlyOneHeader{ColumnIndex 1 eq}{true}ifelse {
PrintHeaderFrame {HeaderFrame}if
HeaderText
} if
} if
0 PrintStartY moveto % move to where printing will start
PLN
} def
/EndPage {
bg { eolbg } if
} def
/EndDSCPage {
ColumnIndex NumberOfColumns eq {
% ---- on last column, spit out the page
showpage
% ---- restore the state of the page
pageState restore
/ColumnIndex 1 def
} { % else
% ---- restore the state of the current column
columnState restore
% ---- and translate to the next column
ColumnWidth 0 translate
/ColumnIndex ColumnIndex 1 add def
} ifelse
} def
/SetHeaderLines { % nb-lines --
/HeaderLines exch def
% ---- bottom up
HeaderPad
HeaderLines 1 sub HeaderLineHeight mul add
HeaderTitleLineHeight add
HeaderPad add
/HeaderHeight exch def
} def
% |---------|
% | tm |
% |---------|
% | header |
% |-+-------| <-- (x y)
% | ho |
% |---------|
% | text |
% |-+-------| <-- (0 0)
% | bm |
% |---------|
/HeaderFrameStart { % -- x y
0 PrintHeight HeaderOffset add
} def
/HeaderFramePath {
PrintHeaderWidth 0 rlineto
0 HeaderHeight rlineto
PrintHeaderWidth neg 0 rlineto
0 HeaderHeight neg rlineto
} def
/HeaderFrame {
gsave
0.4 setlinewidth
% ---- fill a black rectangle (the shadow of the next one)
HeaderFrameStart moveto
1 -1 rmoveto
HeaderFramePath
0 setgray fill
% ---- do the next rectangle ...
HeaderFrameStart moveto
HeaderFramePath
gsave 0.9 setgray fill grestore % filled with grey
gsave 0 setgray stroke grestore % drawn with black
grestore
} def
/HeaderStart {
HeaderFrameStart
exch HeaderPad add exch % horizontal pad
% ---- bottom up
HeaderPad add % vertical pad
HeaderDescent sub
HeaderLineHeight HeaderLines 1 sub mul add
} def
/strcat {
dup length 3 -1 roll dup length dup 4 -1 roll add string dup
0 5 -1 roll putinterval
dup 4 2 roll exch putinterval
} def
/pagenumberstring {
PageNumber 32 string cvs
ShowNofN {
(/) strcat
PageCount 32 string cvs strcat
} if
} def
/HeaderText {
HeaderStart moveto
HeaderLinesRight HeaderLinesLeft % -- rightLines leftLines
% ---- hack: `PN 1 and' == `PN 2 modulo'
% ---- if duplex and even page number, then exchange left and right
Duplex PageNumber 1 and 0 eq and { exch } if
{ % ---- process the left lines
aload pop
exch F
gsave
dup xcheck { exec } if
show
grestore
0 HeaderLineHeight neg rmoveto
} forall
HeaderStart moveto
{ % ---- process the right lines
aload pop
exch F
gsave
dup xcheck { exec } if
dup stringwidth pop
PrintHeaderWidth exch sub HeaderPad 2 mul sub 0 rmoveto
show
grestore
0 HeaderLineHeight neg rmoveto
} forall
} def
/ReportFontInfo {
2 copy
/t0 3 1 roll DefFont
/t0 F
/lh FontHeight def
/sw ( ) stringwidth pop def
/aw (01234567890abcdefghijklmnopqrstuvwxyz) dup length exch
stringwidth pop exch div def
/t1 12 /Helvetica-Oblique DefFont
/t1 F
gsave
(For ) show
128 string cvs show
( ) show
32 string cvs show
( point, the line height is ) show
lh 32 string cvs show
(, the space width is ) show
sw 32 string cvs show
(,) show
grestore
0 FontHeight neg rmoveto
gsave
(and a crude estimate of average character width is ) show
aw 32 string cvs show
(.) show
grestore
0 FontHeight neg rmoveto
} def
/cm { % cm to point
72 mul 2.54 div
} def
/ReportAllFontInfo {
FontDirectory
{ % key = font name value = font dictionary
pop 10 exch ReportFontInfo
} forall
} def
% 3 cm 20 cm moveto 10 /Courier ReportFontInfo showpage
% 3 cm 20 cm moveto ReportAllFontInfo showpage
")
(defvar ps-print-prologue-2
"
% ---- These lines must be kept together because...
/h0 F
/HeaderTitleLineHeight FontHeight def
/h1 F
/HeaderLineHeight FontHeight def
/HeaderDescent Descent def
% ---- ...because `F' has a side-effect on `FontHeight' and `Descent'
")
(defvar ps-source-buffer nil)
(defvar ps-spool-buffer-name "*PostScript*")
(defvar ps-spool-buffer nil)
(defvar ps-output-head nil)
(defvar ps-output-tail nil)
(defvar ps-page-postscript 0)
(defvar ps-page-count 0)
(defvar ps-showline-count 1)
(defvar ps-control-or-escape-regexp nil)
(defvar ps-background-pages nil)
(defvar ps-background-all-pages nil)
(defvar ps-background-text-count 0)
(defvar ps-background-image-count 0)
(defvar ps-current-font 0)
(defvar ps-default-color (and ps-print-color-p ps-default-fg)) (defvar ps-current-color ps-default-color)
(defvar ps-current-bg nil)
(defvar ps-razchunk 0)
(defvar ps-color-p nil)
(defvar ps-color-format
(if (eq ps-print-emacs-type 'emacs)
"%0.3f %0.3f %0.3f"
"%s %s %s"))
(defvar ps-header-pad 0
"Vertical and horizontal space between the header frame and the text.
This is in units of points (1/72 inch).")
(defmacro ps-page-dimensions-get-width (dims) `(nth 0 ,dims))
(defmacro ps-page-dimensions-get-height (dims) `(nth 1 ,dims))
(defvar ps-landscape-page-height nil)
(defvar ps-print-width nil)
(defvar ps-print-height nil)
(defvar ps-height-remaining nil)
(defvar ps-width-remaining nil)
(defvar ps-print-color-scale nil)
(defvar ps-font-size-internal nil)
(defvar ps-header-font-size-internal nil)
(defvar ps-header-title-font-size-internal nil)
(defvar ps-print-face-extension-alist nil
"Alist of symbolic faces *WITH* extension features (box, outline, etc).
An element of this list has the following form:
(FACE . [BITS FG BG])
FACE is a symbol denoting a face name
BITS is a bit vector, where each bit correspond
to a feature (bold, underline, etc)
(see documentation for `ps-print-face-map-alist')
FG foreground color (string or nil)
BG background color (string or nil)
Don't change this list directly; instead,
use `ps-extend-face' and `ps-extend-face-list'.
See documentation for `ps-extend-face' for valid extension symbol.")
(defvar ps-print-face-alist nil
"Alist of symbolic faces *WITHOUT* extension features (box, outline, etc).
An element of this list has the same form as an element of
`ps-print-face-extension-alist'.
Don't change this list directly; this list is used by `ps-face-attributes',
`ps-map-face' and `ps-build-reference-face-lists'.")
(defconst ps-print-face-map-alist
'((bold . 1)
(italic . 2)
(underline . 4)
(strikeout . 8)
(overline . 16)
(shadow . 32)
(box . 64)
(outline . 128))
"Alist of all features and the corresponding bit mask.
Each symbol correspond to one bit in a bit vector.")
(defun ps-extend-face-list (face-extension-list &optional merge-p)
"Extend face in `ps-print-face-extension-alist'.
If optional MERGE-P is non-nil, extensions in FACE-EXTENSION-LIST are merged
with face extension in `ps-print-face-extension-alist'; otherwise, overrides.
The elements in FACE-EXTENSION-LIST is like those for `ps-extend-face'.
See `ps-extend-face' for documentation."
(while face-extension-list
(ps-extend-face (car face-extension-list) merge-p)
(setq face-extension-list (cdr face-extension-list))))
(defun ps-extend-face (face-extension &optional merge-p)
"Extend face in `ps-print-face-extension-alist'.
If optional MERGE-P is non-nil, extensions in FACE-EXTENSION list are merged
with face extensions in `ps-print-face-extension-alist'; otherwise, overrides.
The elements of FACE-EXTENSION list have the form:
(FACE-NAME FOREGROUND BACKGROUND EXTENSION...)
FACE-NAME is a face name symbol.
FOREGROUND and BACKGROUND may be nil or a string that denotes the
foreground and background colors respectively.
EXTENSION is one of the following symbols:
bold - use bold font.
italic - use italic font.
underline - put a line under text.
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.
If EXTENSION is any other symbol, it is ignored."
(let* ((face-name (nth 0 face-extension))
(foreground (nth 1 face-extension))
(background (nth 2 face-extension))
(ps-face (cdr (assq face-name ps-print-face-extension-alist)))
(face-vector (or ps-face (vector 0 nil nil)))
(face-bit (ps-extension-bit face-extension)))
(aset face-vector 0 (if merge-p
(logior (aref face-vector 0) face-bit)
face-bit))
(and foreground (stringp foreground) (aset face-vector 1 foreground))
(and background (stringp background) (aset face-vector 2 background))
(or ps-face
(setq ps-print-face-extension-alist
(cons (cons face-name face-vector)
ps-print-face-extension-alist)))))
(defun ps-extension-bit (face-extension)
(let ((face-bit 0))
(setq face-extension (cdr (cdr face-extension)))
(while (setq face-extension (cdr face-extension))
(setq face-bit (logior face-bit
(or (cdr (assq (car face-extension)
ps-print-face-map-alist))
0))))
face-bit))
(defun ps-font-lock-face-attributes ()
(and (boundp 'font-lock-mode) (symbol-value 'font-lock-mode)
(boundp 'font-lock-face-attributes)
(let ((face-attributes font-lock-face-attributes))
(while face-attributes
(let* ((face-attribute
(car (prog1 face-attributes
(setq face-attributes (cdr face-attributes)))))
(face (car face-attribute)))
(unless (get face 'saved-face)
(let ((foreground (nth 1 face-attribute))
(background (nth 2 face-attribute))
(bold-p (nth 3 face-attribute))
(italic-p (nth 4 face-attribute))
(underline-p (nth 5 face-attribute))
face-spec)
(when foreground
(setq face-spec (cons ':foreground
(cons foreground face-spec))))
(when background
(setq face-spec (cons ':background
(cons background face-spec))))
(when bold-p
(setq face-spec (append '(:bold t) face-spec)))
(when italic-p
(setq face-spec (append '(:italic t) face-spec)))
(when underline-p
(setq face-spec (append '(:underline t) face-spec)))
(custom-declare-face face (list (list t face-spec)) nil)
)))))))
(make-local-hook 'ps-print-hook)
(make-local-hook 'ps-print-begin-page-hook)
(make-local-hook 'ps-print-begin-column-hook)
(defun ps-print-without-faces (from to &optional filename region-p)
(ps-spool-without-faces from to region-p)
(ps-do-despool filename))
(defun ps-spool-without-faces (from to &optional region-p)
(run-hooks 'ps-print-hook)
(ps-printing-region region-p)
(ps-generate (current-buffer) from to 'ps-generate-postscript))
(defun ps-print-with-faces (from to &optional filename region-p)
(ps-spool-with-faces from to region-p)
(ps-do-despool filename))
(defun ps-spool-with-faces (from to &optional region-p)
(run-hooks 'ps-print-hook)
(ps-printing-region region-p)
(ps-generate (current-buffer) from to 'ps-generate-postscript-with-faces))
(defsubst ps-count-lines (from to)
(+ (count-lines from to)
(save-excursion
(goto-char to)
(if (= (current-column) 0) 1 0))))
(defvar ps-printing-region nil
"Variable used to indicate if ps-print is printing a region.
If non-nil, it is a cons, the car of which is the line number
where the region begins, and its cdr is the total number of lines
in the buffer. Formatting functions can use this information
to print the original line number (and not the number of lines printed),
and to indicate in the header that the printout is of a partial file.")
(defun ps-printing-region (region-p)
(setq ps-printing-region
(and region-p
(cons (ps-count-lines (point-min) (region-beginning))
(ps-count-lines (point-min) (point-max))))))
(defsubst ps-font-alist (font-sym)
(get font-sym 'fonts))
(defun ps-font (font-sym font-type)
"Font family name for text of `font-type', when generating PostScript."
(let* ((font-list (ps-font-alist font-sym))
(normal-font (cdr (assq 'normal font-list))))
(while (and font-list (not (eq font-type (car (car font-list)))))
(setq font-list (cdr font-list)))
(or (cdr (car font-list)) normal-font)))
(defun ps-fonts (font-sym)
(mapcar 'cdr (ps-font-alist font-sym)))
(defun ps-font-number (font-sym font-type)
(or (ps-alist-position font-type (ps-font-alist font-sym))
0))
(defsubst ps-line-height (font-sym)
"The height of a line, for generating PostScript.
This is the value that ps-print uses to determine the height,
y-dimension, of the lines of text it has printed, and thus affects the
point at which page-breaks are placed.
The line-height is *not* the same as the point size of the font."
(get font-sym 'line-height))
(defsubst ps-title-line-height (font-sym)
"The height of a `title' line, for generating PostScript.
This is the value that ps-print uses to determine the height,
y-dimension, of the lines of text it has printed, and thus affects the
point at which page-breaks are placed.
The title-line-height is *not* the same as the point size of the font."
(get font-sym 'title-line-height))
(defsubst ps-space-width (font-sym)
"The width of a space character, for generating PostScript.
This value is used in expanding tab characters."
(get font-sym 'space-width))
(defsubst ps-avg-char-width (font-sym)
"The average width, in points, of a character, for generating PostScript.
This is the value that ps-print uses to determine the length,
x-dimension, of the text it has printed, and thus affects the point at
which long lines wrap around."
(get font-sym 'avg-char-width))
(defun ps-line-lengths-internal ()
"Display the correspondence between a line length and a font size,
using the current ps-print setup.
Try: pr -t file | awk '{printf \"%3d %s\n\", length($0), $0}' | sort -r | head"
(let ((buf (get-buffer-create "*Line-lengths*"))
(ifs ps-font-size-internal) (icw (ps-avg-char-width 'ps-font-for-text)) (print-width (progn (ps-get-page-dimensions)
ps-print-width))
(ps-setup (ps-setup)) (fs-min 5) cw-min nb-cpl-max (fs-max 14) cw-max nb-cpl-min fs cw nb-cpl )
(setq cw-min (/ (* icw fs-min) ifs)
nb-cpl-max (floor (/ print-width cw-min))
cw-max (/ (* icw fs-max) ifs)
nb-cpl-min (floor (/ print-width cw-max))
nb-cpl nb-cpl-min)
(set-buffer buf)
(goto-char (point-max))
(or (bolp) (insert "\n"))
(insert ps-setup
"nb char per line / font size\n")
(while (<= nb-cpl nb-cpl-max)
(setq cw (/ print-width (float nb-cpl))
fs (/ (* ifs cw) icw))
(insert (format "%3s %s\n" nb-cpl fs))
(setq nb-cpl (1+ nb-cpl)))
(insert "\n")
(display-buffer buf 'not-this-window)))
(defun ps-nb-pages (nb-lines)
"Display correspondence between font size and the number of pages.
The correspondence is based on having NB-LINES lines of text,
and on the current ps-print setup."
(let ((buf (get-buffer-create "*Nb-Pages*"))
(ifs ps-font-size-internal) (ilh (ps-line-height 'ps-font-for-text)) (page-height (progn (ps-get-page-dimensions)
ps-print-height))
(ps-setup (ps-setup)) (fs-min 4) lh-min nb-lpp-max nb-page-min (fs-max 14) lh-max nb-lpp-min nb-page-max fs lh nb-lpp nb-page )
(setq lh-min (/ (* ilh fs-min) ifs)
nb-lpp-max (floor (/ page-height lh-min))
nb-page-min (ceiling (/ (float nb-lines) nb-lpp-max))
lh-max (/ (* ilh fs-max) ifs)
nb-lpp-min (floor (/ page-height lh-max))
nb-page-max (ceiling (/ (float nb-lines) nb-lpp-min))
nb-page nb-page-min)
(set-buffer buf)
(goto-char (point-max))
(or (bolp) (insert "\n"))
(insert ps-setup
(format "%d lines\n" nb-lines)
"nb page / font size\n")
(while (<= nb-page nb-page-max)
(setq nb-lpp (ceiling (/ nb-lines (float nb-page)))
lh (/ page-height nb-lpp)
fs (/ (* ifs lh) ilh))
(insert (format "%s %s\n" nb-page fs))
(setq nb-page (1+ nb-page)))
(insert "\n")
(display-buffer buf 'not-this-window)))
(defmacro ps-lookup (key) `(cdr (assq ,key font-entry)))
(defmacro ps-size-scale (key) `(/ (* (ps-lookup ,key) font-size) size))
(defun ps-select-font (font-family sym font-size title-font-size)
(let ((font-entry (cdr (assq font-family ps-font-info-database))))
(or font-entry
(error "Don't have data to scale font %s. Known fonts families are %s"
font-family
(mapcar 'car ps-font-info-database)))
(let ((size (ps-lookup 'size)))
(put sym 'fonts (ps-lookup 'fonts))
(put sym 'space-width (ps-size-scale 'space-width))
(put sym 'avg-char-width (ps-size-scale 'avg-char-width))
(put sym 'line-height (ps-size-scale 'line-height))
(put sym 'title-line-height
(/ (* (ps-lookup 'line-height) title-font-size) size)))))
(defun ps-get-page-dimensions ()
(let ((page-dimensions (cdr (assq ps-paper-type ps-page-dimensions-database)))
page-width page-height)
(cond
((null page-dimensions)
(error "`ps-paper-type' must be one of:\n%s"
(mapcar 'car ps-page-dimensions-database)))
((< ps-number-of-columns 1)
(error "The number of columns %d should be positive"
ps-number-of-columns)))
(ps-select-font ps-font-family 'ps-font-for-text
ps-font-size-internal ps-font-size-internal)
(ps-select-font ps-header-font-family 'ps-font-for-header
ps-header-font-size-internal
ps-header-title-font-size-internal)
(setq page-width (ps-page-dimensions-get-width page-dimensions)
page-height (ps-page-dimensions-get-height page-dimensions))
(if ps-landscape-mode
(setq page-width (prog1 page-height (setq page-height page-width))))
(setq ps-landscape-page-height page-height)
(setq ps-print-width (/ (- page-width
ps-left-margin ps-right-margin
(* (1- ps-number-of-columns) ps-inter-column))
ps-number-of-columns))
(if (<= ps-print-width 0)
(error "Bad horizontal layout:
page-width == %s
ps-left-margin == %s
ps-right-margin == %s
ps-inter-column == %s
ps-number-of-columns == %s
| lm | text | ic | text | ic | text | rm |
page-width == lm + n * print-width + (n - 1) * ic + rm
=> print-width == %d !"
page-width
ps-left-margin
ps-right-margin
ps-inter-column
ps-number-of-columns
ps-print-width))
(setq ps-print-height
(- page-height ps-bottom-margin ps-top-margin))
(if (<= ps-print-height 0)
(error "Bad vertical layout:
ps-top-margin == %s
ps-bottom-margin == %s
page-height == bm + print-height + tm
=> print-height == %d !"
ps-top-margin
ps-bottom-margin
ps-print-height))
(if ps-print-header
(setq ps-header-pad (* ps-header-line-pad
(ps-title-line-height 'ps-font-for-header))
ps-print-height (- ps-print-height
ps-header-offset
ps-header-pad
(ps-title-line-height 'ps-font-for-header)
(* (ps-line-height 'ps-font-for-header)
(1- ps-header-lines))
ps-header-pad)))
(if (<= ps-print-height 0)
(error "Bad vertical layout:
ps-top-margin == %s
ps-bottom-margin == %s
ps-header-offset == %s
ps-header-pad == %s
header-height == %s
page-height == bm + print-height + tm - ho - hh
=> print-height == %d !"
ps-top-margin
ps-bottom-margin
ps-header-offset
ps-header-pad
(+ ps-header-pad
(ps-title-line-height 'ps-font-for-header)
(* (ps-line-height 'ps-font-for-header)
(1- ps-header-lines))
ps-header-pad)
ps-print-height))))
(defun ps-print-preprint (&optional filename)
(and filename
(or (numberp filename)
(listp filename))
(let* ((name (concat (file-name-nondirectory (or (buffer-file-name)
(buffer-name)))
".ps"))
(prompt (format "Save PostScript to file: (default %s) " name))
(res (read-file-name prompt default-directory name nil)))
(while (cond ((not (file-writable-p res))
(ding)
(setq prompt "is unwritable"))
((file-exists-p res)
(setq prompt "exists")
(not (y-or-n-p (format "File `%s' exists; overwrite? "
res))))
(t nil))
(setq res (read-file-name
(format "File %s; save PostScript to file: " prompt)
(file-name-directory res) nil nil
(file-name-nondirectory res))))
(if (file-directory-p res)
(expand-file-name name (file-name-as-directory res))
res))))
(defvar ps-string-escape-codes
(let ((table (make-vector 256 nil))
(char ?\000))
(while (<= char ?\037)
(aset table char (format "\\%03o" char))
(setq char (1+ char)))
(while (< char ?\177)
(aset table char (format "%c" char))
(setq char (1+ char)))
(while (<= char ?\377)
(aset table char (format "\\%o" char))
(setq char (1+ char)))
(aset table ?\n "\\n") (aset table ?\r "\\r") (aset table ?\t "\\t") (aset table ?\b "\\b") (aset table ?\f "\\f") (aset table ?\\ "\\\\")
(aset table ?\( "\\(")
(aset table ?\) "\\)")
table)
"Vector used to map characters to PostScript string escape codes.")
(defun ps-output-string-prim (string)
(insert "(") (save-excursion (insert (string-as-unibyte string)))
(while (progn (skip-chars-forward " -'*-[]-~") (not (eobp)))
(let ((special (following-char)))
(delete-char 1)
(insert (aref ps-string-escape-codes special))))
(goto-char (point-max))
(insert ")"))
(defun ps-init-output-queue ()
(setq ps-output-head '("")
ps-output-tail ps-output-head))
(defun ps-output (&rest args)
(setcdr ps-output-tail args)
(while (cdr ps-output-tail)
(setq ps-output-tail (cdr ps-output-tail))))
(defun ps-output-string (string)
(ps-output t string))
(defun ps-output-list (the-list)
(mapcar 'ps-output the-list))
(defun ps-output-prologue (args)
(ps-output 'prologue (if (stringp args) (list args) args)))
(defun ps-flush-output ()
(save-excursion
(set-buffer ps-spool-buffer)
(goto-char (point-max))
(while ps-output-head
(let ((it (car ps-output-head)))
(cond
((eq t it)
(setq ps-output-head (cdr ps-output-head))
(ps-output-string-prim (car ps-output-head)))
((eq 'prologue it)
(setq ps-output-head (cdr ps-output-head))
(save-excursion
(search-backward "\nBeginDoc")
(forward-char 1)
(apply 'insert (car ps-output-head))))
(t
(insert it))))
(setq ps-output-head (cdr ps-output-head))))
(ps-init-output-queue))
(defun ps-insert-file (fname)
(ps-flush-output)
(or (file-readable-p fname)
(error "Could not read file `%s'" fname))
(save-excursion
(set-buffer ps-spool-buffer)
(goto-char (point-max))
(insert-file fname)))
(defun ps-generate-header-line (fonttag &optional content)
(ps-output " [ " fonttag " ")
(cond
((stringp content)
(ps-output content))
((and (symbolp content) (fboundp content))
(ps-output-string (funcall content)))
((and (symbolp content) (boundp content))
(ps-output-string (symbol-value content)))
(t
(ps-output-string "")))
(ps-output " ]\n"))
(defun ps-generate-header (name contents)
(ps-output "/" name " [\n")
(if (> ps-header-lines 0)
(let ((count 1))
(ps-generate-header-line "/h0" (car contents))
(while (and (< count ps-header-lines)
(setq contents (cdr contents)))
(ps-generate-header-line "/h1" (car contents))
(setq count (1+ count)))
(ps-output "] def\n"))))
(defun ps-output-boolean (name bool)
(ps-output (format "/%s %s def\n" name (if bool "true" "false"))))
(defun ps-background-pages (page-list func)
(if page-list
(mapcar
'(lambda (pages)
(let ((start (if (consp pages) (car pages) pages))
(end (if (consp pages) (cdr pages) pages)))
(and (integerp start) (integerp end) (<= start end)
(add-to-list 'ps-background-pages (vector start end func)))))
page-list)
(setq ps-background-all-pages (cons func ps-background-all-pages))))
(defun ps-get-boundingbox ()
(save-excursion
(set-buffer ps-spool-buffer)
(save-excursion
(if (re-search-forward
"^%%BoundingBox:\\s-+\\([0-9.]+\\)\\s-+\\([0-9.]+\\)\\s-+\\([0-9.]+\\)\\s-+\\([0-9.]+\\)"
nil t)
(vector (string-to-number (buffer-substring (match-beginning 1) (match-end 1)))
(string-to-number (buffer-substring (match-beginning 2) (match-end 2)))
(string-to-number (buffer-substring (match-beginning 3) (match-end 3)))
(string-to-number (buffer-substring (match-beginning 4) (match-end 4))))
(vector 0 0 0 0)))))
(defvar ps-float-format (if (eq ps-print-emacs-type 'emacs)
"%0.3f " "%s "))
(defun ps-float-format (value &optional default)
(let ((literal (or value default)))
(if literal
(format (if (numberp literal)
ps-float-format
"%s ")
literal)
" ")))
(defun ps-background-text ()
(mapcar
'(lambda (text)
(setq ps-background-text-count (1+ ps-background-text-count))
(ps-output (format "/ShowBackText-%d {\n" ps-background-text-count))
(ps-output-string (nth 0 text)) (ps-output
"\n"
(ps-float-format (nth 4 text) 200.0) (format "/%s " (or (nth 3 text) "Times-Roman")) (ps-float-format (nth 6 text)
"PrintHeight PrintPageWidth atan") (ps-float-format (nth 5 text) 0.85) (ps-float-format (nth 1 text) "0") (ps-float-format (nth 2 text) "BottomMargin") "\nShowBackText} def\n")
(ps-background-pages (nthcdr 7 text) (format "ShowBackText-%d\n"
ps-background-text-count)))
ps-print-background-text))
(defun ps-background-image ()
(mapcar
'(lambda (image)
(let ((image-file (expand-file-name (nth 0 image))))
(if (file-readable-p image-file)
(progn
(setq ps-background-image-count (1+ ps-background-image-count))
(ps-output
(format "/ShowBackImage-%d {\n--back-- " ps-background-image-count)
(ps-float-format (nth 5 image) 0.0) (ps-float-format (nth 3 image) 1.0) (ps-float-format (nth 4 image) 1.0) (ps-float-format (nth 1 image) "PrintPageWidth 2 div")
(ps-float-format (nth 2 image) "PrintHeight 2 div BottomMargin add")
"\nBeginBackImage\n")
(ps-insert-file image-file)
(let ((box (ps-get-boundingbox)))
(save-excursion
(set-buffer ps-spool-buffer)
(save-excursion
(if (re-search-backward "^--back--" nil t)
(replace-match
(format "%s %s"
(ps-float-format
(- (+ (/ (- (aref box 2) (aref box 0)) 2.0)
(aref box 0))))
(ps-float-format
(- (+ (/ (- (aref box 3) (aref box 1)) 2.0)
(aref box 1)))))
t)))))
(ps-output "\nEndBackImage} def\n")
(ps-background-pages (nthcdr 6 image) (format "ShowBackImage-%d\n"
ps-background-image-count))))))
ps-print-background-image))
(defun ps-background (page-number)
(let (has-local-background)
(mapcar '(lambda (range)
(and (<= (aref range 0) page-number)
(<= page-number (aref range 1))
(if has-local-background
(ps-output (aref range 2))
(setq has-local-background t)
(ps-output "/printLocalBackground {\n"
(aref range 2)))))
ps-background-pages)
(and has-local-background (ps-output "} def\n"))))
(defun ps-remove-duplicates (list)
(let (new (tail list))
(while tail
(or (member (car tail) new)
(setq new (cons (car tail) new)))
(setq tail (cdr tail)))
(nreverse new)))
(defun ps-alist-position (item list)
(let ((tail list) (index 0) found)
(while tail
(if (setq found (eq (car (car tail)) item))
(setq tail nil)
(setq index (1+ index)
tail (cdr tail))))
(and found index)))
(defun ps-begin-file ()
(ps-get-page-dimensions)
(setq ps-page-postscript 0
ps-background-text-count 0
ps-background-image-count 0
ps-background-pages nil
ps-background-all-pages nil)
(ps-output ps-adobe-tag
"%%Title: " (buffer-name) "\n%%Creator: " (user-full-name)
" (using ps-print v" ps-print-version
")\n%%CreationDate: "
(time-stamp-hh:mm:ss) " " (time-stamp-mon-dd-yyyy)
"\n%%Orientation: "
(if ps-landscape-mode "Landscape" "Portrait")
"\n%%DocumentNeededResources: font Times-Roman Times-Italic\n%%+ font "
(mapconcat 'identity
(ps-remove-duplicates
(append (ps-fonts 'ps-font-for-text)
(list (ps-font 'ps-font-for-header 'normal)
(ps-font 'ps-font-for-header 'bold))))
"\n%%+ font ")
"\n%%Pages: (atend)\n%%Requirements:"
(if ps-spool-duplex " duplex\n" "\n"))
(let ((comments (if (functionp ps-print-prologue-header)
(funcall ps-print-prologue-header)
ps-print-prologue-header)))
(and (stringp comments)
(ps-output comments)))
(ps-output "%%EndComments\n\n%%BeginPrologue\n\n")
(ps-output-boolean "LandscapeMode" ps-landscape-mode)
(ps-output (format "/NumberOfColumns %d def\n" ps-number-of-columns)
(format "/LandscapePageHeight %s def\n" ps-landscape-page-height)
(format "/PrintPageWidth %s def\n"
(- (* (+ ps-print-width ps-inter-column)
ps-number-of-columns)
ps-inter-column))
(format "/PrintWidth %s def\n" ps-print-width)
(format "/PrintHeight %s def\n" ps-print-height)
(format "/LeftMargin %s def\n" ps-left-margin)
(format "/RightMargin %s def\n" ps-right-margin) (format "/InterColumn %s def\n" ps-inter-column)
(format "/BottomMargin %s def\n" ps-bottom-margin)
(format "/TopMargin %s def\n" ps-top-margin) (format "/HeaderOffset %s def\n" ps-header-offset)
(format "/HeaderPad %s def\n" ps-header-pad))
(ps-output-boolean "PrintHeader" ps-print-header)
(ps-output-boolean "PrintOnlyOneHeader" ps-print-only-one-header)
(ps-output-boolean "PrintHeaderFrame" ps-print-header-frame)
(ps-output-boolean "ShowNofN" ps-show-n-of-n)
(ps-output-boolean "Duplex" ps-spool-duplex)
(let ((line-height (ps-line-height 'ps-font-for-text)))
(ps-output (format "/LineHeight %s def\n" line-height)
(format "/LinesPerColumn %d def\n"
(round (/ (+ ps-print-height
(* line-height 0.45))
line-height)))))
(ps-output-boolean "Zebra" ps-zebra-stripes)
(ps-output-boolean "PrintLineNumber" ps-line-number)
(ps-output (format "/ZebraHeight %d def\n" ps-zebra-stripe-height))
(ps-background-text)
(ps-background-image)
(setq ps-background-all-pages (nreverse ps-background-all-pages)
ps-background-pages (nreverse ps-background-pages))
(ps-output ps-print-prologue-1)
(ps-output "/printGlobalBackground {\n")
(ps-output-list ps-background-all-pages)
(ps-output "} def\n/printLocalBackground {\n} def\n")
(ps-output (format "/h0 %s (%s) cvn DefFont\n" ps-header-title-font-size-internal
(ps-font 'ps-font-for-header 'bold))
(format "/h1 %s (%s) cvn DefFont\n" ps-header-font-size-internal
(ps-font 'ps-font-for-header 'normal)))
(ps-output ps-print-prologue-2)
(let ((font (ps-font-alist 'ps-font-for-text))
(i 0))
(while font
(ps-output (format "/f%d %s (%s) cvn DefFont\n"
i
ps-font-size-internal
(ps-font 'ps-font-for-text (car (car font)))))
(setq font (cdr font)
i (1+ i))))
(let ((font-entry (cdr (assq ps-font-family ps-font-info-database))))
(ps-output (format "/SpaceWidthRatio %f def\n"
(/ (ps-lookup 'space-width) (ps-lookup 'size)))))
(ps-output "\n%%EndPrologue\n\n%%BeginSetup\nBeginDoc\n%%EndSetup\n"))
(defun ps-header-dirpart ()
(let ((fname (buffer-file-name)))
(if fname
(if (string-equal (buffer-name) (file-name-nondirectory fname))
(file-name-directory fname)
fname)
"")))
(defun ps-get-buffer-name ()
(cond
((string= (buffer-name) "ps-print.el")
"Hey, Cool! It's ps-print.el!!!")
((string= (buffer-name) "sokoban.el")
"Super! C'est sokoban.el!")
(t (concat
(and ps-printing-region "Subset of: ")
(buffer-name)
(and (buffer-modified-p) " (unsaved)")))))
(defun ps-get-font-size (font-sym)
(let ((font-size (symbol-value font-sym)))
(cond ((numberp font-size)
font-size)
((and (consp font-size)
(numberp (car font-size))
(numberp (cdr font-size)))
(if ps-landscape-mode
(car font-size)
(cdr font-size)))
(t
(error "Invalid font size `%S' for `%S'" font-size font-sym)))))
(defun ps-begin-job ()
(save-excursion
(set-buffer ps-spool-buffer)
(goto-char (point-max))
(and (re-search-backward "^%%Trailer$" nil t)
(delete-region (match-beginning 0) (point-max))))
(setq ps-showline-count (if ps-printing-region (car ps-printing-region) 1)
ps-page-count 0
ps-font-size-internal (ps-get-font-size 'ps-font-size)
ps-header-font-size-internal (ps-get-font-size 'ps-header-font-size)
ps-header-title-font-size-internal
(ps-get-font-size 'ps-header-title-font-size)
ps-control-or-escape-regexp
(cond ((eq ps-print-control-characters '8-bit)
(string-as-unibyte "[\000-\037\177-\377]"))
((eq ps-print-control-characters 'control-8-bit)
(string-as-unibyte "[\000-\037\177-\237]"))
((eq ps-print-control-characters 'control)
"[\000-\037\177]")
(t "[\t\n\f]"))))
(defmacro ps-page-number ()
`(1+ (/ (1- ps-page-count) ps-number-of-columns)))
(defun ps-end-file ()
(ps-output "\n%%Trailer\n%%Pages: "
(format "%d" ps-page-postscript)
"\n\nEndDoc\n\n%%EOF\n"))
(defun ps-next-page ()
(ps-end-page)
(ps-flush-output)
(ps-begin-page))
(defun ps-header-page ()
(if (prog1
(zerop (mod ps-page-count ps-number-of-columns))
(setq ps-page-count (1+ ps-page-count)))
(progn
(setq ps-page-postscript (1+ ps-page-postscript))
(ps-output (format "\n%%%%Page: %d %d\n"
ps-page-postscript ps-page-postscript))
(ps-output "/Lines 0 def\n/PageCount 0 def\nBeginDSCPage\n")
(ps-background ps-page-postscript)
(run-hooks 'ps-print-begin-page-hook))
(ps-output "/Lines 0 def\n/PageCount 0 def\nBeginDSCPage\n")
(run-hooks 'ps-print-begin-column-hook)))
(defun ps-begin-page ()
(ps-get-page-dimensions)
(setq ps-width-remaining ps-print-width
ps-height-remaining ps-print-height)
(ps-header-page)
(ps-output (format "/LineNumber %d def\n" ps-showline-count)
(format "/PageNumber %d def\n" (if ps-print-only-one-header
(ps-page-number)
ps-page-count)))
(when ps-print-header
(ps-generate-header "HeaderLinesLeft" ps-left-header)
(ps-generate-header "HeaderLinesRight" ps-right-header)
(ps-output (format "%d SetHeaderLines\n" ps-header-lines)))
(ps-output "BeginPage\n")
(ps-set-font ps-current-font)
(ps-set-bg ps-current-bg)
(ps-set-color ps-current-color)
(ps-mule-begin-page))
(defun ps-end-page ()
(ps-output "EndPage\nEndDSCPage\n"))
(defun ps-dummy-page ()
(ps-header-page)
(ps-output "/PrintHeader false def
BeginPage
EndPage
EndDSCPage\n"))
(defun ps-next-line ()
(setq ps-showline-count (1+ ps-showline-count))
(let ((lh (ps-line-height 'ps-font-for-text)))
(if (< ps-height-remaining lh)
(ps-next-page)
(setq ps-width-remaining ps-print-width
ps-height-remaining (- ps-height-remaining lh))
(ps-output "HL\n"))))
(defun ps-continue-line ()
(let ((lh (ps-line-height 'ps-font-for-text)))
(if (< ps-height-remaining lh)
(ps-next-page)
(setq ps-width-remaining ps-print-width
ps-height-remaining (- ps-height-remaining lh))
(ps-output "SL\n"))))
(defun ps-find-wrappoint (from to char-width)
(let ((avail (truncate (/ ps-width-remaining char-width)))
(todo (- to from)))
(if (< todo avail)
(cons to (* todo char-width))
(cons (+ from avail) ps-width-remaining))))
(defun ps-basic-plot-string (from to &optional bg-color)
(let* ((wrappoint (ps-find-wrappoint from to
(ps-avg-char-width 'ps-font-for-text)))
(to (car wrappoint))
(string (buffer-substring-no-properties from to)))
(ps-mule-prepare-ascii-font string)
(ps-output-string string)
(ps-output " S\n")
wrappoint))
(defun ps-basic-plot-whitespace (from to &optional bg-color)
(let* ((wrappoint (ps-find-wrappoint from to
(ps-space-width 'ps-font-for-text)))
(to (car wrappoint)))
(ps-output (format "%d W\n" (- to from)))
wrappoint))
(defun ps-plot (plotfunc from to &optional bg-color)
(while (< from to)
(let* ((wrappoint (funcall plotfunc from to bg-color))
(plotted-to (car wrappoint))
(plotted-width (cdr wrappoint)))
(setq from plotted-to
ps-width-remaining (- ps-width-remaining plotted-width))
(if (< from to)
(ps-continue-line))))
(if ps-razzle-dazzle
(let* ((q-todo (- (point-max) (point-min)))
(q-done (- (point) (point-min)))
(chunkfrac (/ q-todo 8))
(chunksize (min chunkfrac 1000)))
(if (> (- q-done ps-razchunk) chunksize)
(progn
(setq ps-razchunk q-done)
(message "Formatting...%3d%%"
(if (< q-todo 100)
(/ (* 100 q-done) q-todo)
(/ q-done (/ q-todo 100)))
))))))
(defvar ps-last-font nil)
(defun ps-set-font (font)
(setq ps-last-font (format "f%d" (setq ps-current-font font)))
(ps-output (format "/%s F\n" ps-last-font)))
(defun ps-set-bg (color)
(if (setq ps-current-bg color)
(ps-output (format ps-color-format
(nth 0 color) (nth 1 color) (nth 2 color))
" true BG\n")
(ps-output "false BG\n")))
(defun ps-set-color (color)
(setq ps-current-color (or color ps-default-fg))
(ps-output (format ps-color-format
(nth 0 ps-current-color)
(nth 1 ps-current-color) (nth 2 ps-current-color))
" FG\n"))
(defvar ps-current-effect 0)
(defun ps-plot-region (from to font &optional fg-color bg-color effects)
(if (not (equal font ps-current-font))
(ps-set-font font))
(if (not (equal fg-color ps-current-color))
(ps-set-color fg-color))
(if (not (equal bg-color ps-current-bg))
(ps-set-bg bg-color))
(cond
((not (integerp effects))
(ps-output "0 EF\n")
(setq ps-current-effect 0))
((/= effects ps-current-effect)
(ps-output (number-to-string effects) " EF\n")
(setq ps-current-effect effects)))
(save-excursion
(goto-char from)
(while (< from to)
(if (re-search-forward ps-control-or-escape-regexp to t)
(let* ((match-point (match-beginning 0))
(match (char-after match-point)))
(when (< from match-point)
(ps-mule-set-ascii-font)
(ps-plot 'ps-basic-plot-string from match-point bg-color))
(cond
((= match ?\t) (let ((linestart (line-beginning-position)))
(forward-char -1)
(setq from (+ linestart (current-column)))
(when (re-search-forward "[ \t]+" to t)
(ps-mule-set-ascii-font)
(ps-plot 'ps-basic-plot-whitespace
from (+ linestart (current-column))
bg-color))))
((= match ?\n) (ps-next-line))
((= match ?\f) (or (and (= (char-after (1- match-point)) ?\n)
(= ps-height-remaining ps-print-height))
(ps-next-page)))
((> match 255) (let ((charset (char-charset match)))
(or (eq charset 'composition)
(while (eq (charset-after) charset)
(forward-char 1)))
(ps-plot 'ps-mule-plot-string match-point (point) bg-color)))
(t (ps-control-character match)))
(setq from (point)))
(ps-mule-set-ascii-font)
(ps-plot 'ps-basic-plot-string from to bg-color)
(setq from to)))))
(defvar ps-string-control-codes
(let ((table (make-vector 256 nil))
(char ?\000))
(while (<= char ?\037)
(aset table char (format "^%c" (+ char ?@)))
(setq char (1+ char)))
(while (< char ?\177)
(aset table char (format "%c" char))
(setq char (1+ char)))
(aset table char "^?")
(while (<= (setq char (1+ char)) ?\377)
(aset table char (format "\\%o" char)))
table)
"Vector used to map characters to a printable string.")
(defun ps-control-character (char)
(let* ((str (aref ps-string-control-codes char))
(from (1- (point)))
(len (length str))
(to (+ from len))
(char-width (ps-avg-char-width 'ps-font-for-text))
(wrappoint (ps-find-wrappoint from to char-width)))
(if (< (car wrappoint) to)
(ps-continue-line))
(setq ps-width-remaining (- ps-width-remaining (* len char-width)))
(ps-mule-prepare-ascii-font str)
(ps-output-string str)
(ps-output " S\n")))
(defun ps-color-value (x-color-value)
(/ x-color-value ps-print-color-scale))
(cond ((eq ps-print-emacs-type 'emacs)
(defun ps-color-values (x-color)
(if (fboundp 'x-color-values)
(x-color-values x-color)
(error "No available function to determine X color values.")))
)
(t (defun ps-color-values (x-color)
(cond ((fboundp 'x-color-values)
(x-color-values x-color))
((and (fboundp 'color-instance-rgb-components)
(ps-color-device))
(color-instance-rgb-components
(if (color-instance-p x-color)
x-color
(make-color-instance
(if (color-specifier-p x-color)
(color-name x-color)
x-color)))))
(t (error "No available function to determine X color values."))))
))
(defun ps-face-attributes (face)
"Return face attribute vector.
If FACE is not in `ps-print-face-extension-alist' or in
`ps-print-face-alist', insert it on `ps-print-face-alist' and
return the attribute vector.
If FACE is not a valid face name, it is used default face."
(cdr (or (assq face ps-print-face-extension-alist)
(assq face ps-print-face-alist)
(let* ((the-face (if (facep face) face 'default))
(new-face (ps-screen-to-bit-face the-face)))
(or (and (eq the-face 'default)
(assq the-face ps-print-face-alist))
(setq ps-print-face-alist (cons new-face ps-print-face-alist)))
new-face))))
(defun ps-face-attribute-list (face-or-list)
(if (listp face-or-list)
(let ((effects 0)
foreground background face-attr)
(while face-or-list
(setq face-attr (ps-face-attributes (car face-or-list))
effects (logior effects (aref face-attr 0)))
(or foreground (setq foreground (aref face-attr 1)))
(or background (setq background (aref face-attr 2)))
(setq face-or-list (cdr face-or-list)))
(vector effects foreground background))
(ps-face-attributes face-or-list)))
(defconst ps-font-type (vector nil 'bold 'italic 'bold-italic))
(defun ps-plot-with-face (from to face)
(cond
((null face) (ps-plot-region from to 0))
((eq face 'emacs--invisible--face)) (t (let* ((face-bit (ps-face-attribute-list face))
(effect (aref face-bit 0))
(foreground (aref face-bit 1))
(background (aref face-bit 2))
(fg-color (if (and ps-color-p foreground)
(mapcar 'ps-color-value
(ps-color-values foreground))
ps-default-color))
(bg-color (and ps-color-p background
(mapcar 'ps-color-value
(ps-color-values background)))))
(ps-plot-region
from to
(ps-font-number 'ps-font-for-text
(or (aref ps-font-type (logand effect 3))
face))
fg-color bg-color (lsh effect -2)))))
(goto-char to))
(defun ps-xemacs-face-kind-p (face kind kind-regex kind-list)
(let* ((frame-font (or (face-font-instance face)
(face-font-instance 'default)))
(kind-cons (and frame-font
(assq kind
(font-instance-properties frame-font))))
(kind-spec (cdr-safe kind-cons))
(case-fold-search t))
(or (and kind-spec (string-match kind-regex kind-spec))
(memq face kind-list))))
(cond ((eq ps-print-emacs-type 'emacs)
(defun ps-face-bold-p (face)
(or (face-bold-p face)
(memq face ps-bold-faces)))
(defun ps-face-italic-p (face)
(or (face-italic-p face)
(memq face ps-italic-faces)))
)
(t (defun ps-face-bold-p (face)
(ps-xemacs-face-kind-p face 'WEIGHT_NAME "bold\\|demibold"
ps-bold-faces))
(defun ps-face-italic-p (face)
(or (ps-xemacs-face-kind-p face 'ANGLE_NAME "i\\|o" ps-italic-faces)
(ps-xemacs-face-kind-p face 'SLANT "i\\|o" ps-italic-faces)))
))
(defun ps-face-underlined-p (face)
(or (face-underline-p face)
(memq face ps-underlined-faces)))
(or (fboundp 'face-list) (defalias 'face-list 'list-faces))
(defun ps-build-reference-face-lists ()
(ps-font-lock-face-attributes)
(setq ps-print-face-alist nil)
(if ps-auto-font-detect
(mapcar 'ps-map-face (face-list))
(mapcar 'ps-set-face-bold ps-bold-faces)
(mapcar 'ps-set-face-italic ps-italic-faces)
(mapcar 'ps-set-face-underline ps-underlined-faces))
(setq ps-build-face-reference nil))
(defun ps-set-face-bold (face)
(ps-set-face-attribute face 1))
(defun ps-set-face-italic (face)
(ps-set-face-attribute face 2))
(defun ps-set-face-underline (face)
(ps-set-face-attribute face 4))
(defun ps-set-face-attribute (face effect)
(let ((face-bit (cdr (ps-map-face face))))
(aset face-bit 0 (logior (aref face-bit 0) effect))))
(defun ps-map-face (face)
(let* ((face-map (ps-screen-to-bit-face face))
(ps-face-bit (cdr (assq (car face-map) ps-print-face-alist))))
(if ps-face-bit
(let ((face-bit (cdr face-map)))
(aset ps-face-bit 0 (logior (aref ps-face-bit 0) (aref face-bit 0)))
(or (aref ps-face-bit 1) (aset ps-face-bit 1 (aref face-bit 1)))
(or (aref ps-face-bit 2) (aset ps-face-bit 2 (aref face-bit 2))))
(setq ps-print-face-alist (cons face-map ps-print-face-alist)))
face-map))
(defun ps-screen-to-bit-face (face)
(cons face
(vector (logior (if (ps-face-bold-p face) 1 0) (if (ps-face-italic-p face) 2 0) (if (ps-face-underlined-p face) 4 0)) (face-foreground face)
(face-background face))))
(cond ((not (eq ps-print-emacs-type 'emacs))
(defun ps-mapper (extent list)
(nconc list (list (list (extent-start-position extent) 'push extent)
(list (extent-end-position extent) 'pull extent)))
nil)
(defun ps-extent-sorter (a b)
(< (extent-priority a) (extent-priority b)))
))
(defun ps-print-ensure-fontified (start end)
(and (boundp 'lazy-lock-mode) (symbol-value 'lazy-lock-mode)
(lazy-lock-fontify-region start end)))
(defun ps-generate-postscript-with-faces (from to)
(setq ps-current-effect 0)
(if (or ps-always-build-face-reference
ps-build-face-reference)
(progn
(message "Collecting face information...")
(ps-build-reference-face-lists)))
(setq ps-color-p (and ps-print-color-p (ps-color-device))
ps-print-color-scale (if ps-color-p
(float (car (ps-color-values "white")))
1.0))
(save-restriction
(narrow-to-region from to)
(ps-print-ensure-fontified from to)
(let ((face 'default)
(position to))
(cond
((or (eq ps-print-emacs-type 'lucid)
(eq ps-print-emacs-type 'xemacs))
(let ((a (cons 'dummy nil))
record type extent extent-list)
(map-extents 'ps-mapper nil from to a)
(setq a (sort (cdr a) 'car-less-than-car)
extent-list nil)
(while a
(setq record (car a)
position (car record)
record (cdr record)
type (car record)
record (cdr record)
extent (car record))
(and (>= from (point-min)) (<= position (point-max))
(ps-plot-with-face from position face))
(cond
((eq type 'push)
(and (extent-face extent)
(setq extent-list (sort (cons extent extent-list)
'ps-extent-sorter))))
((eq type 'pull)
(setq extent-list (sort (delq extent extent-list)
'ps-extent-sorter))))
(setq face (if extent-list
(extent-face (car extent-list))
'default)
from position
a (cdr a)))))
((eq ps-print-emacs-type 'emacs)
(let ((property-change from)
(overlay-change from)
(save-buffer-invisibility-spec buffer-invisibility-spec)
(buffer-invisibility-spec nil))
(while (< from to)
(and (< property-change to) (setq property-change (next-property-change from nil to)))
(and (< overlay-change to) (setq overlay-change (min (next-overlay-change from) to)))
(setq position (min property-change overlay-change))
(setq face
(cond ((let ((prop (get-text-property from 'invisible)))
(if (eq save-buffer-invisibility-spec t)
(not (null prop))
(or (memq prop save-buffer-invisibility-spec)
(assq prop save-buffer-invisibility-spec))))
'emacs--invisible--face)
((get-text-property from 'face))
(t 'default)))
(let ((overlays (overlays-at from))
(face-priority -1)) (while (and overlays
(not (eq face 'emacs--invisible--face)))
(let* ((overlay (car overlays))
(overlay-invisible (overlay-get overlay 'invisible))
(overlay-priority (or (overlay-get overlay 'priority)
0)))
(and (> overlay-priority face-priority)
(setq face
(cond ((if (eq save-buffer-invisibility-spec t)
(not (null overlay-invisible))
(or (memq overlay-invisible
save-buffer-invisibility-spec)
(assq overlay-invisible
save-buffer-invisibility-spec)))
'emacs--invisible--face)
((overlay-get overlay 'face))
(t face))
face-priority overlay-priority)))
(setq overlays (cdr overlays))))
(ps-plot-with-face from position face)
(setq from position)))))
(ps-plot-with-face from to face))))
(defun ps-generate-postscript (from to)
(ps-plot-region from to 0 nil))
(defun ps-generate (buffer from to genfunc)
(save-excursion
(let ((from (min to from))
(to (max to from))
(inhibit-read-only t))
(save-restriction
(narrow-to-region from to)
(and ps-razzle-dazzle
(message "Formatting...%3d%%" (setq ps-razchunk 0)))
(setq ps-source-buffer buffer
ps-spool-buffer (get-buffer-create ps-spool-buffer-name))
(ps-init-output-queue)
(let (safe-marker completed-safely needs-begin-file)
(unwind-protect
(progn
(set-buffer ps-spool-buffer)
(set-buffer-multibyte nil)
(setq safe-marker (make-marker))
(set-marker safe-marker (point-max))
(goto-char (point-min))
(or (looking-at (regexp-quote ps-adobe-tag))
(setq needs-begin-file t))
(save-excursion
(set-buffer ps-source-buffer)
(ps-begin-job)
(when needs-begin-file
(ps-begin-file)
(ps-mule-initialize))
(ps-mule-begin-job from to)
(ps-begin-page))
(set-buffer ps-source-buffer)
(funcall genfunc from to)
(ps-end-page)
(and ps-spool-duplex (= (mod ps-page-count 2) 1)
(ps-dummy-page))
(ps-end-file)
(ps-flush-output)
(let ((total-lines (if ps-printing-region
(cdr ps-printing-region)
(ps-count-lines (point-min) (point-max))))
(total-pages (if ps-print-only-one-header
(ps-page-number)
ps-page-count)))
(set-buffer ps-spool-buffer)
(goto-char (point-min))
(while (re-search-forward "^/Lines 0 def\n/PageCount 0 def$"
nil t)
(replace-match (format "/Lines %d def\n/PageCount %d def"
total-lines total-pages) t)))
(setq completed-safely t))
(and (markerp safe-marker) (not completed-safely)
(progn
(set-buffer ps-spool-buffer)
(delete-region (marker-position safe-marker) (point-max))))))
(and ps-razzle-dazzle (message "Formatting...done"))))))
(defvar dos-ps-printer nil)
(defun ps-do-despool (filename)
(if (or (not (boundp 'ps-spool-buffer))
(not (symbol-value 'ps-spool-buffer)))
(message "No spooled PostScript to print")
(if filename
(save-excursion
(and ps-razzle-dazzle (message "Saving..."))
(set-buffer ps-spool-buffer)
(setq filename (expand-file-name filename))
(let ((coding-system-for-write 'raw-text-unix))
(write-region (point-min) (point-max) filename))
(and ps-razzle-dazzle (message "Wrote %s" filename)))
(and ps-razzle-dazzle (message "Printing..."))
(save-excursion
(set-buffer ps-spool-buffer)
(let* ((coding-system-for-write 'raw-text-unix)
(ps-printer-name (or ps-printer-name
(and (boundp 'printer-name)
printer-name)))
(ps-lpr-switches
(append
(and (stringp ps-printer-name)
(list (concat "-P" ps-printer-name)))
ps-lpr-switches)))
(apply (or ps-print-region-function 'call-process-region)
(point-min) (point-max) ps-lpr-command nil
(and (fboundp 'start-process) 0)
nil
(ps-flatten-list (mapcar 'ps-eval-switch ps-lpr-switches)))))
(and ps-razzle-dazzle (message "Printing...done")))
(kill-buffer ps-spool-buffer)))
(defun ps-eval-switch (arg)
(cond ((stringp arg) arg)
((functionp arg) (apply arg nil))
((symbolp arg) (symbol-value arg))
((consp arg) (apply (car arg) (cdr arg)))
(t nil)))
(defun ps-flatten-list (&rest list)
(ps-flatten-list-1 list))
(defun ps-flatten-list-1 (list)
(cond ((null list) nil)
((consp list) (append (ps-flatten-list-1 (car list))
(ps-flatten-list-1 (cdr list))))
(t (list list))))
(defun ps-kill-emacs-check ()
(let (ps-buffer)
(and (setq ps-buffer (get-buffer ps-spool-buffer-name))
(buffer-modified-p ps-buffer)
(y-or-n-p "Unprinted PostScript waiting; print now? ")
(ps-despool))
(and (setq ps-buffer (get-buffer ps-spool-buffer-name))
(buffer-modified-p ps-buffer)
(not (yes-or-no-p "Unprinted PostScript waiting; exit anyway? "))
(error "Unprinted PostScript"))))
(cond ((fboundp 'add-hook)
(funcall 'add-hook 'kill-emacs-hook 'ps-kill-emacs-check))
(kill-emacs-hook
(message "Won't override existing `kill-emacs-hook'"))
(t
(setq kill-emacs-hook 'ps-kill-emacs-check)))
(defmacro ps-prsc ()
`(if (eq ps-print-emacs-type 'emacs) [f22] 'f22))
(defmacro ps-c-prsc ()
`(if (eq ps-print-emacs-type 'emacs) [C-f22] '(control f22)))
(defmacro ps-s-prsc ()
`(if (eq ps-print-emacs-type 'emacs) [S-f22] '(shift f22)))
(defun ps-rmail-mode-hook ()
(local-set-key (ps-prsc) 'ps-rmail-print-message-from-summary)
(setq ps-header-lines 3
ps-left-header
'(ps-article-subject ps-article-author buffer-name)))
(defun ps-rmail-print-message-from-summary ()
(interactive)
(ps-print-message-from-summary 'rmail-summary-buffer "RMAIL"))
(defun ps-print-message-from-summary (summary-buffer summary-default)
(let ((ps-buf (or (and (boundp summary-buffer)
(symbol-value summary-buffer))
summary-default)))
(and (get-buffer ps-buf)
(save-excursion
(set-buffer ps-buf)
(ps-spool-buffer-with-faces)))))
(defun ps-article-subject ()
(save-excursion
(goto-char (point-min))
(if (re-search-forward "^Subject:[ \t]+\\(.*\\)$" nil t)
(buffer-substring-no-properties (match-beginning 1) (match-end 1))
"Subject ???")))
(defun ps-article-author ()
(save-excursion
(goto-char (point-min))
(if (re-search-forward "^From:[ \t]+\\(.*\\)$" nil t)
(let ((fromstring (buffer-substring-no-properties (match-beginning 1)
(match-end 1))))
(cond
((string-match ".*[ \t]+(\\(.*\\))" fromstring)
(substring fromstring (match-beginning 1) (match-end 1)))
((string-match "\\(.*\\)[ \t]+<.*>" fromstring)
(substring fromstring (match-beginning 1) (match-end 1)))
(t fromstring)))
"From ???")))
(defun ps-gnus-article-prepare-hook ()
(setq ps-header-lines 3
ps-left-header
'(ps-article-subject ps-article-author gnus-newsgroup-name)))
(defun ps-vm-mode-hook ()
(local-set-key (ps-prsc) 'ps-vm-print-message-from-summary)
(setq ps-header-lines 3
ps-left-header
'(ps-article-subject ps-article-author buffer-name)))
(defun ps-gnus-print-article-from-summary ()
(interactive)
(ps-print-message-from-summary 'gnus-article-buffer "*Article*"))
(defun ps-vm-print-message-from-summary ()
(interactive)
(ps-print-message-from-summary 'vm-mail-buffer ""))
(defun ps-gnus-summary-setup ()
(local-set-key (ps-prsc) 'ps-gnus-print-article-from-summary))
(defun ps-info-file ()
(save-excursion
(goto-char (point-min))
(if (re-search-forward "File:[ \t]+\\([^, \t\n]*\\)" nil t)
(buffer-substring-no-properties (match-beginning 1) (match-end 1))
"File ???")))
(defun ps-info-node ()
(save-excursion
(goto-char (point-min))
(if (re-search-forward "Node:[ \t]+\\([^,\t\n]*\\)" nil t)
(buffer-substring-no-properties (match-beginning 1) (match-end 1))
"Node ???")))
(defun ps-info-mode-hook ()
(setq ps-left-header
'(ps-info-node ps-info-file)))
(defun ps-jts-ps-setup ()
(global-set-key (ps-prsc) 'ps-spool-buffer-with-faces) (global-set-key (ps-s-prsc) 'ps-spool-region-with-faces)
(global-set-key (ps-c-prsc) 'ps-despool)
(add-hook 'gnus-article-prepare-hook 'ps-gnus-article-prepare-hook)
(add-hook 'gnus-summary-mode-hook 'ps-gnus-summary-setup)
(add-hook 'vm-mode-hook 'ps-vm-mode-hook)
(add-hook 'vm-mode-hooks 'ps-vm-mode-hook)
(add-hook 'Info-mode-hook 'ps-info-mode-hook)
(setq ps-spool-duplex t
ps-print-color-p nil
ps-lpr-command "lpr"
ps-lpr-switches '("-Jjct,duplex_long"))
'ps-jts-ps-setup)
(defun ps-jack-setup ()
(setq ps-print-color-p nil
ps-lpr-command "lpr"
ps-lpr-switches nil
ps-paper-type 'a4
ps-landscape-mode t
ps-number-of-columns 2
ps-left-margin (/ (* 72 1.0) 2.54) ps-right-margin (/ (* 72 1.0) 2.54) ps-inter-column (/ (* 72 1.0) 2.54) ps-bottom-margin (/ (* 72 1.5) 2.54) ps-top-margin (/ (* 72 1.5) 2.54) ps-header-offset (/ (* 72 1.0) 2.54) ps-header-line-pad .15
ps-print-header t
ps-print-header-frame t
ps-header-lines 2
ps-show-n-of-n t
ps-spool-duplex nil
ps-font-family 'Courier
ps-font-size 5.5
ps-header-font-family 'Helvetica
ps-header-font-size 6
ps-header-title-font-size 8)
'ps-jack-setup)
(autoload 'ps-mule-prepare-ascii-font "ps-mule"
"Setup special ASCII font for STRING.
STRING should contain only ASCII characters.")
(autoload 'ps-mule-set-ascii-font "ps-mule"
"Adjust current font if current charset is not ASCII.")
(autoload 'ps-mule-plot-string "ps-mule"
"Generate PostScript code for ploting characters in the region FROM and TO.
It is assumed that all characters in this region belong to the same charset.
Optional argument BG-COLOR specifies background color.
Returns the value:
(ENDPOS . RUN-WIDTH)
Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
the sequence.")
(autoload 'ps-mule-initialize "ps-mule"
"Initialize global data for printing multi-byte characters.")
(autoload 'ps-mule-begin-job "ps-mule"
"Start printing job for multi-byte chars between FROM and TO.
This checks if all multi-byte characters in the region are printable or not.")
(autoload 'ps-mule-begin-page "ps-mule"
"Initialize multi-byte charset for printing current page.")
(provide 'ps-print)