;;; ps-print.el --- Print text from the buffer as PostScript
-;; Copyright (C) 1993, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
+;; Copyright (C) 1993-2000 Free Software Foundation, Inc.
-;; Author: Jim Thompson (was <thompson@wg2.waii.com>)
-;; Author: Jacques Duthen <duthen@cegelec-red.fr>
-;; Author: Vinicius Jose Latorre <vinicius@cpqd.com.br>
-;; Maintainer: Vinicius Jose Latorre <vinicius@cpqd.com.br>
-;; Keywords: print, PostScript
-;; Time-stamp: <98/06/04 15:23:12 vinicius>
-;; Version: 3.06.3
+;; Author: Jim Thompson (was <thompson@wg2.waii.com>)
+;; Author: Jacques Duthen (was <duthen@cegelec-red.fr>)
+;; Author: Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;; Author: Kenichi Handa <handa@etl.go.jp> (multi-byte characters)
+;; Maintainer: Kenichi Handa <handa@etl.go.jp> (multi-byte characters)
+;; Maintainer: Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;; Keywords: wp, print, PostScript
+;; Time-stamp: <2000/06/05 14:40:03 vinicius>
+;; Version: 5.2.2
-(defconst ps-print-version "3.06.3"
- "ps-print.el, v 3.06.3 <98/06/04 vinicius>
+(defconst ps-print-version "5.2.2"
+ "ps-print.el, v 5.2.2 <2000/06/05 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.
+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>.
;;; Commentary:
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; About ps-print
;; --------------
;;
-;; This package provides printing of Emacs buffers on PostScript
-;; printers; the buffer's bold and italic text attributes are
-;; preserved in the printer output. Ps-print is intended for use with
-;; Emacs 19 or Lucid Emacs, together with a fontifying package such as
-;; font-lock or hilit.
+;; This package provides printing of Emacs buffers on PostScript printers;
+;; the buffer's bold and italic text attributes are preserved in the printer
+;; output. ps-print is intended for use with Emacs or Lucid Emacs, together
+;; with a fontifying package such as font-lock or hilit.
;;
;; ps-print uses the same face attributes defined through font-lock or hilit
;; to print a PostScript file, but some faces are better seeing on the screen
;; Using ps-print
;; --------------
;;
-;; The Commands
-;;
-;; Ps-print provides eight commands for generating PostScript images
+;; ps-print provides eight commands for generating PostScript images
;; of Emacs buffers:
;;
;; ps-print-buffer
;; your output at the printer (it's easier to pick up one 50-page
;; printout than to find 50 single-page printouts).
;;
-;; Ps-print has a hook in the `kill-emacs-hook' so that you won't
+;; ps-print has a hook in the `kill-emacs-hook' so that you won't
;; accidentally quit from Emacs while you have unprinted PostScript
;; waiting in the spool buffer. If you do attempt to exit with
;; spooled PostScript, you'll be asked if you want to print it, and if
;; Make sure that they contain appropriate values for your system;
;; see the usage notes below and the documentation of these variables.
;;
+;; The variable `ps-printer-name' determines the name of a local printer for
+;; printing PostScript files.
+;;
;; NOTE: `ps-lpr-command' and `ps-lpr-switches' take their initial values
;; from the variables `lpr-command' and `lpr-switches'. If you have
;; `lpr-command' set to invoke a pretty-printer such as `enscript',
;; then ps-print won't work properly. `ps-lpr-command' must name
;; a program that does not format the files it prints.
+;; `ps-printer-name' takes its initial value from the variable
+;; `printer-name'.
+;;
+;; The variable `ps-print-region-function' specifies a function to print the
+;; region on a PostScript printer.
+;; See definition of `call-process-region' for calling conventions. The fourth
+;; and the sixth arguments are both nil.
+;;
+;; The variable `ps-manual-feed' indicates if the printer will manually feed
+;; paper. If it's nil, automatic feeding takes place. If it's non-nil, manual
+;; feeding takes place. The default is nil (automatic feeding).
+;;
+;; If you're using Emacs for Windows 95/98/NT or MS-DOS, don't forget to
+;; customize the following variables: `ps-printer-name', `ps-lpr-command',
+;; `ps-lpr-switches' and `ps-spool-config'. See these variables documentation
+;; in the code or by typing, for example, C-h v ps-printer-name RET.
;;
;;
;; The Page Layout
;; 1 inch == 2.54 cm == 72 points
;; 1 cm == (/ 1 2.54) inch == (/ 72 2.54) points
;;
-;; The variable `ps-paper-type' determines the size of paper ps-print
-;; formats for; it should contain one of the symbols:
-;; `a4' `a3' `letter' `legal' `letter-small' `tabloid'
-;; `ledger' `statement' `executive' `a4small' `b4' `b5'
-;;
-;; The variable `ps-landscape-mode' determines the orientation
-;; of the printing on the page:
-;; nil means `portrait' mode, non-nil means `landscape' mode.
+;; The variable `ps-paper-type' determines the size of paper ps-print formats
+;; for; it should contain one of the symbols: `a4' `a3' `letter' `legal'
+;; `letter-small' `tabloid' `ledger' `statement' `executive' `a4small' `b4'
+;; `b5'.
+;;
+;; If variable `ps-warn-paper-type' is nil, it's *not* given an error if
+;; PostScript printer doesn't have a paper with the size indicated by
+;; `ps-paper-type', instead it uses the default paper size. If variable
+;; `ps-warn-paper-type' is non-nil, it's given an error if PostScript printer
+;; doesn't have a paper with the size indicated by `ps-paper-type'. It's used
+;; when `ps-spool-config' is set to `setpagedevice' (see section Duplex
+;; Printers). The default value is non-nil (it gives an error).
+;;
+;; The variable `ps-landscape-mode' determines the orientation of the printing
+;; on the page: nil means `portrait' mode, non-nil means `landscape' mode.
;; There is no oblique mode yet, though this is easy to do in ps.
;;
-;; In landscape mode, the text is NOT scaled: you may print 70 lines
-;; in portrait mode and only 50 lignes in landscape mode.
-;; The margins represent margins in the printed paper:
-;; the top margin is the margin between the top of the page
+;; In landscape mode, the text is NOT scaled: you may print 70 lines in portrait
+;; mode and only 50 lines in landscape mode. The margins represent margins in
+;; the printed paper: the top margin is the margin between the top of the page
;; and the printed header, whatever the orientation is.
;;
-;; The variable `ps-number-of-columns' determines the number of columns
-;; both in landscape and portrait mode.
+;; The variable `ps-number-of-columns' determines the number of columns both in
+;; landscape and portrait mode.
;; You can use:
-;; - (the standard) one column portrait mode
-;; - (my favorite) two columns landscape mode (which spares trees)
-;; but also
+;; - (the standard) one column portrait mode.
+;; - (my favorite) two columns landscape mode (which spares trees).
+;; but also:
;; - one column landscape mode for files with very long lines.
-;; - multi-column portrait or landscape mode
+;; - multi-column portrait or landscape mode.
+;;
+;; The variable `ps-print-upside-down' determines other orientation for printing
+;; page: nil means `normal' printing, non-nil means `upside-down' printing. The
+;; default value is nil (`normal' printing).
+;;
+;; The `upside-down' orientation can be used in portrait or landscape mode.
;;
;;
;; Horizontal layout
;; Headers
;; -------
;;
-;; Ps-print can print headers at the top of each column or at the top
+;; ps-print can print headers at the top of each column or at the top
;; of each page; the default headers contain the following four items:
;; on the left, the name of the buffer and, if the buffer is visiting
;; a file, the file's directory; on the right, the page number and
;; To print only one header at the top of each page,
;; set `ps-print-only-one-header' to t.
;;
+;; To switch headers, set `ps-switch-header' to:
+;;
+;; nil Never switch headers.
+;;
+;; t Always switch headers.
+;;
+;; duplex Switch headers only when duplexing is on, that is, when
+;; `ps-spool-duplex' is non-nil (see Duplex Printers).
+;;
+;; Any other value is treated as t. The default value is `duplex'.
+;;
;; The font family and size of text in the header are determined
;; by the variables `ps-header-font-family', `ps-header-font-size' and
;; `ps-header-title-font-size' (see below).
;; title line height to insert between the header frame and the text
;; it contains, both in the vertical and horizontal directions:
;; .5 means half a line.
-
+;;
;; Page numbers are printed in `n/m' format, indicating page n of m pages;
;; to omit the total page count and just print the page number,
;; set `ps-show-n-of-n' to nil.
;; Consider yourself warned!
;;
;;
+;; PostScript Prologue Header
+;; --------------------------
+;;
+;; It is possible to add PostScript prologue header comments besides that
+;; ps-print generates by setting the variable `ps-print-prologue-header'.
+;;
+;; `ps-print-prologue-header' may be a string or a symbol function which returns
+;; a string. Note that this string is inserted on PostScript prologue header
+;; section which is used to define some document characteristic through
+;; PostScript special comments, like "%%Requirements: jog\n".
+;;
+;; By default `ps-print-prologue-header' is nil.
+;;
+;; ps-print always inserts the %%Requirements: comment, so if you need to insert
+;; more requirements put them first in `ps-print-prologue-header' using the
+;; "%%+" comment. For example, if you need to set numcopies to 3 and jog on
+;; requirements and set %%LanguageLevel: to 2, do:
+;;
+;; (setq ps-print-prologue-header
+;; "%%+ numcopies(3) jog\n%%LanguageLevel: 2\n")
+;;
+;; The duplex requirement is inserted by ps-print (see section Duplex Printers).
+;;
+;; Do not forget to terminate the string with "\n".
+;;
+;; For more information about PostScript document comments, see:
+;; PostScript Language Reference Manual (2nd edition)
+;; Adobe Systems Incorporated
+;; Appendix G: Document Structuring Conventions -- Version 3.0
+;;
+;; It is also possible to add an user defined PostScript prologue code before
+;; all generated prologue code by setting the variable
+;; `ps-user-defined-prologue'.
+;;
+;; `ps-user-defined-prologue' may be a string or a symbol function which returns
+;; a string. Note that this string is inserted after `ps-adobe-tag' and
+;; PostScript prologue comments, and before ps-print PostScript prologue code
+;; section. That is, this string is inserted after error handler initialization
+;; and before ps-print settings.
+;;
+;; By default `ps-user-defined-prologue' is nil.
+;;
+;; It's recommended to initiate and terminate the string with "\n".
+;;
+;; It's strongly recommended only insert PostScript code and/or comments
+;; specific for your printing system particularities. For example, some special
+;; initialization that only your printing system needs.
+;;
+;; Do not insert code for duplex printing, n-up printing or error handler,
+;; ps-print handles this in a suitable way.
+;;
+;; For more information about PostScript, see:
+;; PostScript Language Reference Manual (2nd edition)
+;; Adobe Systems Incorporated
+;;
+;;
+;; PostScript Error Handler
+;; ------------------------
+;;
+;; ps-print instruments generated PostScript code with an error handler.
+;;
+;; The variable `ps-error-handler-message' specifies where the error handler
+;; message should be sent.
+;;
+;; Valid values are:
+;;
+;; none catch the error and *DON'T* send any message.
+;;
+;; paper catch the error and print on paper the error message.
+;; This is the default value.
+;;
+;; system catch the error and send back the error message to
+;; printing system. This is useful only if printing system
+;; send back an email reporting the error, or if there is
+;; some other alternative way to report back the error from
+;; the system to you.
+;;
+;; paper-and-system catch the error, print on paper the error message and
+;; send back the error message to printing system.
+;;
+;; Any other value is treated as `paper'.
+;;
+;;
;; Duplex Printers
;; ---------------
;;
-;; If you have a duplex-capable printer (one that prints both sides of
-;; the paper), set `ps-spool-duplex' to t.
-;; Ps-print will insert blank pages to make sure each buffer starts
-;; on the correct side of the paper.
-;; Don't forget to set `ps-lpr-switches' to select duplex printing
-;; for your printer.
+;; If you have a duplex-capable printer (one that prints both sides of the
+;; paper), set `ps-spool-duplex' to t.
+;; ps-print will insert blank pages to make sure each buffer starts on the
+;; correct side of the paper.
+;;
+;; The variable `ps-spool-config' specifies who is the responsable for setting
+;; duplex and page size switches. Valid values are:
+;;
+;; lpr-switches duplex and page size are configured by `ps-lpr-switches'.
+;; Don't forget to set `ps-lpr-switches' to select duplex
+;; printing for your printer.
+;;
+;; setpagedevice duplex and page size are configured by ps-print using the
+;; setpagedevice PostScript operator.
+;;
+;; nil duplex and page size are configured by ps-print *not* using
+;; the setpagedevice PostScript operator.
+;;
+;; Any other value is treated as nil.
+;;
+;; The default value is `lpr-switches'.
+;;
+;; WARNING: The setpagedevice PostScript operator affects ghostview utility when
+;; viewing file generated using landscape. Also on some printers,
+;; setpagedevice affects zebra stripes; on other printers,
+;; setpagedevice affects the left margin.
+;; Besides all that, if your printer does not have the paper size
+;; specified by setpagedevice, your printing will be aborted.
+;; So, if you need to use setpagedevice, set `ps-spool-config' to
+;; `setpagedevice', generate a test file and send it to your printer;
+;; if the printed file isn't ok, set `ps-spool-config' to nil.
+;;
+;; The variable `ps-spool-tumble' specifies how the page images on opposite
+;; sides of a sheet are oriented with respect to each other. If
+;; `ps-spool-tumble' is nil, produces output suitable for binding on the left or
+;; right. If `ps-spool-tumble' is non-nil, produces output suitable for binding
+;; at the top or bottom. It has effect only when `ps-spool-duplex' is non-nil.
+;; The default value is nil.
+;;
+;; Some printer system prints a header page and forces the first page be printed
+;; on header page back, when using duplex. If your printer system has this
+;; behavior, set variable `ps-banner-page-when-duplexing' to t.
+;;
+;; When `ps-banner-page-when-duplexing' is non-nil means the very first page is
+;; skipped. It's like the very first character of buffer (or region) is ^L
+;; (\014).
+;;
+;; The default for `ps-banner-page-when-duplexing' is nil (*don't* skip the very
+;; first page).
+;;
+;;
+;; N-up Printing
+;; -------------
+;;
+;; The variable `ps-n-up-printing' specifies the number of pages per sheet of
+;; paper. The value specified must be between 1 and 100. The default is 1.
+;;
+;; NOTE: some PostScript printer may crash printing if `ps-n-up-printing' is set
+;; to a high value (for example, 23). If this happens, set a lower value.
+;;
+;; The variable `ps-n-up-margin' specifies the margin in points between the
+;; sheet border and the n-up printing. The default is 1 cm (or 0.3937 inches,
+;; or 28.35 points).
+;;
+;; If variable `ps-n-up-border-p' is non-nil a border is drawn around each page.
+;; The default is t.
+;;
+;; The variable `ps-n-up-filling' specifies how page matrix is filled on each
+;; sheet of paper. Following are the valid values for `ps-n-up-filling' with a
+;; filling example using a 3x4 page matrix:
+;;
+;; left-top 1 2 3 4 left-bottom 9 10 11 12
+;; 5 6 7 8 5 6 7 8
+;; 9 10 11 12 1 2 3 4
+;;
+;; right-top 4 3 2 1 right-bottom 12 11 10 9
+;; 8 7 6 5 8 7 6 5
+;; 12 11 10 9 4 3 2 1
+;;
+;; top-left 1 4 7 10 bottom-left 3 6 9 12
+;; 2 5 8 11 2 5 8 11
+;; 3 6 9 12 1 4 7 10
+;;
+;; top-right 10 7 4 1 bottom-right 12 9 6 3
+;; 11 8 5 2 11 8 5 2
+;; 12 9 6 3 10 7 4 1
+;;
+;; Any other value is treated as left-top.
+;;
+;; The default value is left-top.
;;
;;
;; Control And 8-bit Characters
;;
;; Valid values for `ps-print-control-characters' are:
;;
-;; 8-bit This is the value to use when you want an ascii encoding of
-;; any control or non-ascii character. Control characters are
-;; encoded as "^D", and non-ascii characters have an
+;; 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
+;; 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.
+;; 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
+;; nil No ASCII encoding. Any character is printed according the
;; current font.
;;
;; Any other value is treated as nil.
;; Characters TAB, NEWLINE and FORMFEED are always treated by ps-print engine.
;;
;;
+;; Printing Multi-byte Buffer
+;; --------------------------
+;;
+;; See ps-mule.el for documentation.
+;;
+;;
;; Line Number
;; -----------
;;
;; The variable `ps-line-number' specifies whether to number each line;
;; non-nil means do so. The default is nil (don't number each line).
;;
+;; The variable `ps-line-number-step' specifies the interval that line number is
+;; printed. For example, if `ps-line-number-step' is set to 2, the printing
+;; will look like:
+;;
+;; 1 one line
+;; one line
+;; 3 one line
+;; one line
+;; 5 one line
+;; one line
+;; ...
+;;
+;; Valid values are:
+;;
+;; integer an integer that specifies the interval that line number is
+;; printed. If it's lesser than or equal to zero, it's used the
+;; value 1.
+;;
+;; `zebra' specifies that only the line number of the first line in a zebra
+;; stripe is to be printed.
+;;
+;; Any other value is treated as `zebra'.
+;; The default value is 1, so each line number is printed.
+;;
+;; The variable `ps-line-number-start' specifies the starting point in the
+;; interval given by `ps-line-number-step'. For example, if
+;; `ps-line-number-step' is set to 3 and `ps-line-number-start' is set to 3, the
+;; printing will look like:
+;;
+;; one line
+;; one line
+;; 3 one line
+;; one line
+;; one line
+;; 6 one line
+;; one line
+;; one line
+;; 9 one line
+;; one line
+;; ...
+;;
+;; The values for `ps-line-number-start':
+;;
+;; * If `ps-line-number-step' is an integer, must be between 1 and the value
+;; of `ps-line-number-step' inclusive.
+;;
+;; * If `ps-line-number-step' is set to `zebra', must be between 1 and the
+;; value of `ps-zebra-strip-height' inclusive.
+;;
+;; The default value is 1, so the line number of the first line of each interval
+;; is printed.
+;;
;;
;; Zebra Stripes
;; -------------
;; The variable `ps-zebra-stripes' controls whether to print zebra stripes.
;; Non-nil means yes, nil means no. The default is nil.
;;
+;; The variable `ps-zebra-color' controls the zebra stripes gray scale or RGB
+;; color. It should be a float number between 0.0 (black color) and 1.0 (white
+;; color), a string which is a color name, or a list of 3 numbers which
+;; corresponds to the Red Green Blue color scale.
+;; The default is 0.95 (or "gray95", or '(0.95 0.95 0.95)).
+;;
+;; The variable `ps-zebra-stripe-follow' specifies if zebra stripe should
+;; continue on next page or restart on each page. If `ps-zebra-stripe-follow'
+;; is nil, zebra stripe is restarted on each page. If `ps-zebra-stripe-follow'
+;; is non-nil, zebra stripe continues on next page. Visually, we have:
+;;
+;; `ps-zebra-stripe-follow' `ps-zebra-stripe-follow'
+;; is nil is non-nil
+;; Current Page ------------------------ ------------------------
+;; 1 XXXXXXXXXXXXXXXXXXXXX 1 XXXXXXXXXXXXXXXXXXXXX
+;; 2 XXXXXXXXXXXXXXXXXXXXX 2 XXXXXXXXXXXXXXXXXXXXX
+;; 3 XXXXXXXXXXXXXXXXXXXXX 3 XXXXXXXXXXXXXXXXXXXXX
+;; 4 4
+;; 5 5
+;; 6 6
+;; 7 XXXXXXXXXXXXXXXXXXXXX 7 XXXXXXXXXXXXXXXXXXXXX
+;; 8 XXXXXXXXXXXXXXXXXXXXX 8 XXXXXXXXXXXXXXXXXXXXX
+;; ------------------------ ------------------------
+;; Next Page ------------------------ ------------------------
+;; 9 XXXXXXXXXXXXXXXXXXXXX 9 XXXXXXXXXXXXXXXXXXXXX
+;; 10 XXXXXXXXXXXXXXXXXXXXX 10
+;; 11 XXXXXXXXXXXXXXXXXXXXX 11
+;; 12 12
+;; 13 13 XXXXXXXXXXXXXXXXXXXXX
+;; 14 14 XXXXXXXXXXXXXXXXXXXXX
+;; 15 XXXXXXXXXXXXXXXXXXXXX 15 XXXXXXXXXXXXXXXXXXXXX
+;; 16 XXXXXXXXXXXXXXXXXXXXX 16
+;; ------------------------ ------------------------
+;;
;; See also section How Ps-Print Has A Text And/Or Image On Background.
;;
;;
;; Hooks
;; -----
;;
-;; Ps-print has the following hook variables:
+;; ps-print has the following hook variables:
;;
;; `ps-print-hook'
;; It is evaluated once before any printing process. This is the right
;; place to initialize ps-print global data.
;; For an example, see section Adding a New Font Family.
;;
+;; `ps-print-begin-sheet-hook'
+;; It is evaluated on each beginning of sheet of paper.
+;; If `ps-n-up-printing' is equal to 1, `ps-print-begin-page-hook' is never
+;; evaluated.
+;;
;; `ps-print-begin-page-hook'
-;; It is evaluated on each real beginning of page, that is, ps-print
-;; considers each beginning of column as a beginning of page, and a real
-;; beginning of page is when the beginning of column coincides with a
-;; paper change on your printer.
+;; It is evaluated on each beginning of page, except in the beginning
+;; of page that `ps-print-begin-sheet-hook' is evaluated.
;;
;; `ps-print-begin-column-hook'
;; It is evaluated on each beginning of column, except in the beginning
-;; of column that `ps-print-begin-page-hook' is evaluated.
+;; of column that `ps-print-begin-page-hook' is evaluated or that
+;; `ps-print-begin-sheet-hook' is evaluated.
;;
;;
;; Font Managing
;; -------------
;;
-;; Ps-print now knows rather precisely some fonts:
-;; the variable `ps-font-info-database' contains information
-;; for a list of font families (currently mainly `Courier' `Helvetica'
-;; `Times' `Palatino' `Helvetica-Narrow' `NewCenturySchlbk').
-;; Each font family contains the font names for standard, bold, italic
-;; and bold-italic characters, a reference size (usually 10) and the
-;; corresponding line height, width of a space and average character width.
+;; ps-print now knows rather precisely some fonts: the variable
+;; `ps-font-info-database' contains information for a list of font families
+;; (currently mainly `Courier' `Helvetica' `Times' `Palatino' `Helvetica-Narrow'
+;; `NewCenturySchlbk'). Each font family contains the font names for standard,
+;; bold, italic and bold-italic characters, a reference size (usually 10) and
+;; the corresponding line height, width of a space and average character width.
+;;
+;; The variable `ps-font-family' determines which font family is to be used for
+;; ordinary text. If its value does not correspond to a known font family, an
+;; error message is printed into the `*Messages*' buffer, which lists the
+;; currently available font families.
;;
-;; The variable `ps-font-family' determines which font family
-;; is to be used for ordinary text.
-;; If its value does not correspond to a known font family,
-;; an error message is printed into the `*Messages*' buffer,
-;; which lists the currently available font families.
+;; The variable `ps-font-size' determines the size (in points) of the font for
+;; ordinary text, when generating PostScript. Its value is a float or a cons of
+;; floats which has the following form:
;;
-;; The variable `ps-font-size' determines the size (in points)
-;; of the font for ordinary text, when generating Postscript.
-;; Its value is a float.
+;; (LANDSCAPE-SIZE . PORTRAIT-SIZE)
;;
-;; Similarly, the variable `ps-header-font-family' determines
-;; which font family is to be used for text in the header.
-;; The variable `ps-header-font-size' determines the font size,
-;; in points, for text in the header.
-;; The variable `ps-header-title-font-size' determines the font size,
-;; in points, for the top line of text in the header.
+;; Similarly, the variable `ps-header-font-family' determines which font family
+;; is to be used for text in the header.
+;;
+;; The variable `ps-header-font-size' determines the font size, in points, for
+;; text in the header (similar to `ps-font-size').
+;;
+;; The variable `ps-header-title-font-size' determines the font size, in points,
+;; for the top line of text in the header (similar to `ps-font-size').
;;
;;
;; Adding a New Font Family
;; (setq ps-font-info-database '(<your stuff> <the standard stuff>))
;; or, use `ps-print-hook' (see section Hooks):
;; (add-hook 'ps-print-hook
-;; '(lambda () (setq ps-font-info-database (append ...))))
+;; '(lambda ()
+;; (or (assq 'Helvetica ps-font-info-database)
+;; (setq ps-font-info-database (append ...)))))
;;
;; You can create new `mixed' font families like:
;; (my-mixed-family
;; (line-height . 10.55)
;; (space-width . 6.0)
;; (avg-char-width . 6.0))
+;;
;; Now you can use your new font family with any size:
;; (setq ps-font-family 'my-mixed-family)
;;
;; Faces like bold-italic that are both bold and italic should go in
;; *both* lists.
;;
-;; Ps-print keeps internal lists of which fonts are bold and which are
+;; ps-print keeps internal lists of which fonts are bold and which are
;; italic; these lists are built the first time you invoke ps-print.
;; For the sake of efficiency, the lists are built only once; the same
;; lists are referred in later invocations of ps-print.
;; rebuilt when ps-print is invoked, set the variable
;; `ps-always-build-face-reference' to t.
;;
+;; If you need to print without worrying about face background color, set the
+;; variable `ps-use-face-background' which specifies if face background should
+;; be used. Valid values are:
+;;
+;; t always use face background color.
+;; nil never use face background color.
+;; (face...) list of faces whose background color will be used.
+;;
+;; Any other value will be treated as t.
+;; The default value is t.
+;;
;;
;; How Ps-Print Deals With Color
;; -----------------------------
;;
-;; Ps-print detects faces with foreground and background colors
+;; ps-print detects faces with foreground and background colors
;; defined and embeds color information in the PostScript image.
;; The default foreground and background colors are defined by the
;; variables `ps-default-fg' and `ps-default-bg'.
-;; On black-and-white printers, colors are displayed in grayscale.
+;; On black-and-white printers, colors are displayed in gray scale.
;; To turn off color output, set `ps-print-color-p' to nil.
;;
;;
;;
;; See the documentation for `ps-extend-face'.
;;
-;; Let's, for example, remap font-lock-keyword-face to another foreground color
-;; and bold attribute:
+;; Let's, for example, remap `font-lock-keyword-face' to another foreground
+;; color and bold attribute:
;;
;; (ps-extend-face '(font-lock-keyword-face "RoyalBlue" nil bold) 'MERGE)
;;
;; How Ps-Print Has A Text And/Or Image On Background
;; --------------------------------------------------
;;
-;; Ps-print can print texts and/or EPS PostScript images on background; it is
+;; ps-print can print texts and/or EPS PostScript images on background; it is
;; possible to define the following text attributes: font name, font size,
;; initial position, angle, gray scale and pages to print.
;;
;;
;; The printing order is:
;;
-;; 1. Print zebra stripes
-;; 2. Print background texts that it should be on all pages
-;; 3. Print background images that it should be on all pages
-;; 4. Print background texts only for current page (if any)
-;; 5. Print background images only for current page (if any)
-;; 6. Print header
-;; 7. Print buffer text (with faces, if specified) and line number
+;; 1. Print background color
+;; 2. Print zebra stripes
+;; 3. Print background texts that it should be on all pages
+;; 4. Print background images that it should be on all pages
+;; 5. Print background texts only for current page (if any)
+;; 6. Print background images only for current page (if any)
+;; 7. Print header
+;; 8. Print buffer text (with faces, if specified) and line number
;;
;;
;; Utilities
;; NOTE: line folding is not taken into account in this process and could
;; change the results.
;;
+;; The command `ps-print-customize' activates a customization buffer for
+;; ps-print options.
+;;
;;
;; New since version 1.5
;; ---------------------
;; New since version 2.8
;; ---------------------
;;
+;; [vinicius] 20000310 Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;;
+;; PostScript error handler.
+;; `ps-user-defined-prologue' and `ps-error-handler-message'.
+;;
+;; [vinicius] 991211 Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;;
+;; `ps-print-customize'.
+;;
+;; [vinicius] 990703 Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;;
+;; Better customization.
+;; `ps-banner-page-when-duplexing' and `ps-zebra-color'.
+;;
+;; [vinicius] 990513 Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;;
+;; N-up printing.
+;; Hook: `ps-print-begin-sheet-hook'.
+;;
+;; [keinichi] 990509 Kein'ichi Handa <handa@etl.go.jp>
+;;
+;; `ps-print-region-function'
+;;
+;; [vinicius] 990301 Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;;
+;; PostScript tumble and setpagedevice.
+;;
+;; [vinicius] 980922 Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;;
+;; PostScript prologue header comment insertion.
+;; Skip invisible text better.
+;;
+;; [keinichi] 980819 Kein'ichi Handa <handa@etl.go.jp>
+;;
+;; Multi-byte buffer handling.
+;;
;; [vinicius] 980306 Vinicius Jose Latorre <vinicius@cpqd.com.br>
;;
-;; Skip invisible text
+;; Skip invisible text.
;;
;; [vinicius] 971130 Vinicius Jose Latorre <vinicius@cpqd.com.br>
;;
;; Tools for page setup.
;;
;;
-;; Known bugs and limitations of ps-print:
+;; Known bugs and limitations of ps-print
;; --------------------------------------
;;
;; Although color printing will work in XEmacs 19.12, it doesn't work
;;
;; Faces are always treated as opaque.
;;
-;; Epoch and Emacs 18 not supported. At all.
+;; Epoch and Emacs 19 not supported. At all.
;;
;; Fixed-pitch fonts work better for line folding, but are not required.
;;
;; of folding lines.
;;
;;
-;; Things to change:
+;; Things to change
;; ----------------
;;
;; Avoid page break inside a paragraph.
;; Acknowledgements
;; ----------------
;;
+;; Thanks to Paul Furnanz <pfurnanz@synopsys.com> for XEmacs compatibility
+;; suggestion for `ps-postscript-code-directory' variable.
+;;
+;; Thanks to David X Callaway <dxc@xprt.net> for helping debugging PostScript
+;; level 1 compatibility.
+;;
+;; Thanks to Colin Marquardt <colin.marquardt@usa.alcatel.com> for upside-down,
+;; line number step, line number start and zebra stripe follow suggestions, and
+;; for XEmacs beta-tests.
+;;
+;; Thanks to Klaus Berndl <klaus.berndl@sdm.de> for user defined PostScript
+;; prologue code suggestion.
+;;
+;; Thanks to Kein'ichi Handa <handa@etl.go.jp> for multi-byte buffer handling.
+;;
+;; Thanks to Matthew O Persico <Matthew.Persico@lazard.com> for line number on
+;; empty columns.
+;;
+;; Thanks to Theodore Jump <tjump@cais.com> for adjust PostScript code order on
+;; last page.
+;;
;; Thanks to Roland Ducournau <ducour@lirmm.fr> for
;; `ps-print-control-characters' variable documentation.
;;
;; interest.
;;
;; Jim
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Code:
(unless (featurep 'lisp-float-type)
(error "`ps-print' requires floating point support"))
+
+;; For Emacs 20.2 and the earlier version.
+
+(or (fboundp 'set-buffer-multibyte)
+ (defun set-buffer-multibyte (arg)
+ (setq enable-multibyte-characters arg)))
+
+(or (fboundp 'string-as-unibyte)
+ (defun string-as-unibyte (arg) arg))
+
+(or (fboundp 'string-as-multibyte)
+ (defun string-as-multibyte (arg) arg))
+
+(or (fboundp 'charset-after)
+ (defun charset-after (&optional arg)
+ (char-charset (char-after arg))))
+
+
+(or (fboundp 'line-beginning-position)
+ (defun line-beginning-position (&optional n)
+ (save-excursion
+ (and n (/= n 1) (forward-line (1- n)))
+ (beginning-of-line)
+ (point))))
+
+
+(defconst ps-windows-system
+ (memq system-type '(emx win32 w32 mswindows ms-dos windows-nt)))
+(defconst ps-lp-system
+ (memq system-type '(usq-unix-v dgux hpux irix)))
+
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; User Variables:
+
;;; Interface to the command system
+(defgroup postscript nil
+ "PostScript Group"
+ :tag "PostScript"
+ :group 'emacs)
+
(defgroup ps-print nil
"PostScript generator for Emacs 19"
:prefix "ps-"
- :group 'wp)
+ :group 'wp
+ :group 'postscript)
(defgroup ps-print-horizontal nil
"Horizontal page layout"
:tag "Vertical"
:group 'ps-print)
-(defgroup ps-print-header nil
+(defgroup ps-print-headers nil
"Headers layout"
:prefix "ps-"
:tag "Header"
:group 'ps-print
:group 'faces)
+(defgroup ps-print-n-up nil
+ "N-up customization"
+ :prefix "ps-"
+ :tag "N-Up"
+ :group 'ps-print)
+
+(defgroup ps-print-zebra nil
+ "Zebra customization"
+ :prefix "ps-"
+ :tag "Zebra"
+ :group 'ps-print)
+
+(defgroup ps-print-background nil
+ "Background customization"
+ :prefix "ps-"
+ :tag "Background"
+ :group 'ps-print)
+
+(defgroup ps-print-printer nil
+ "Printer customization"
+ :prefix "ps-"
+ :tag "Printer"
+ :group 'ps-print)
+
+(defgroup ps-print-page nil
+ "Page customization"
+ :prefix "ps-"
+ :tag "Page"
+ :group 'ps-print)
+
+(defgroup ps-print-miscellany nil
+ "Miscellany customization"
+ :prefix "ps-"
+ :tag "Miscellany"
+ :group 'ps-print)
+
+
+(defcustom ps-error-handler-message 'paper
+ "*Specify where the error handler message should be sent.
+
+Valid values are:
+
+ `none' catch the error and *DON'T* send any message.
+
+ `paper' catch the error and print on paper the error message.
+
+ `system' catch the error and send back the error message to
+ printing system. This is useful only if printing system
+ send back an email reporting the error, or if there is
+ some other alternative way to report back the error from
+ the system to you.
+
+ `paper-and-system' catch the error, print on paper the error message and
+ send back the error message to printing system.
+
+Any other value is treated as `paper'."
+ :type '(choice :menu-tag "Error Handler Message"
+ :tag "Error Handler Message"
+ (const none) (const paper)
+ (const system) (const paper-and-system))
+ :group 'ps-print-miscellany)
+
+(defcustom ps-user-defined-prologue nil
+ "*User defined PostScript prologue code inserted before all prologue code.
+
+`ps-user-defined-prologue' may be a string or a symbol function which returns a
+string. Note that this string is inserted after `ps-adobe-tag' and PostScript
+prologue comments, and before ps-print PostScript prologue code section. That
+is, this string is inserted after error handler initialization and before
+ps-print settings.
+
+It's recommended to initiate and terminate the string with \"\\n\".
+
+It's strongly recommended only insert PostScript code and/or comments specific
+for your printing system particularities. For example, some special
+initialization that only your printing system needs.
+
+Do not insert code for duplex printing, n-up printing or error handler, ps-print
+handles this in a suitable way.
+
+For more information about PostScript, see:
+ PostScript Language Reference Manual (2nd edition)
+ Adobe Systems Incorporated"
+ :type '(choice :menu-tag "User Defined Prologue"
+ :tag "User Defined Prologue"
+ (const :tag "none" nil) string symbol)
+ :group 'ps-print-miscellany)
+
+(defcustom ps-print-prologue-header nil
+ "*PostScript prologue header comments besides that ps-print generates.
-(defcustom ps-printer-name printer-name
+`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 :menu-tag "Prologue Header"
+ :tag "Prologue Header"
+ (const :tag "none" nil) string symbol)
+ :group 'ps-print-miscellany)
+
+(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; otherwise the value should be nil.
-
-On MS-DOS and MS-Windows systems, if the value is a string, then it is
-taken as the name of the device to which PostScript files are written.
-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\".
-
-On DOS/Windows, if the value is anything but a string, PostScript files
-will be piped to the program given by `ps-lpr-command', with switches
-given by `ps-lpr-switches', which see."
- :type '(choice file (other :tag "Pipe to ps-lpr-command" pipe))
- :group 'ps-print)
+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 :menu-tag "Printer Name"
+ :tag "Printer Name"
+ (const :tag "Same as printer-name" nil)
+ (file :tag "Print to file")
+ (string :tag "Pipe to ps-lpr-command"))
+ :group 'ps-print-printer)
(defcustom ps-lpr-command lpr-command
- "*The shell command for printing a PostScript file."
+ "*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)
+ :group 'ps-print-printer)
(defcustom ps-lpr-switches lpr-switches
"*A list of extra switches to pass to `ps-lpr-command'."
- :type '(repeat string)
- :group 'ps-print)
+ :type '(repeat :tag "PostScript lpr Switches"
+ (choice string symbol (repeat sexp)))
+ :group 'ps-print-printer)
+
+(defcustom ps-print-region-function nil
+ "*Specify a function to print the region on a PostScript printer.
+See definition of `call-process-region' for calling conventions. The fourth and
+the sixth arguments are both nil."
+ :type 'function
+ :group 'ps-print-printer)
+
+(defcustom ps-manual-feed nil
+ "*Non-nil means the printer will manually feed paper.
+
+If it's nil, automatic feeding takes place."
+ :type 'boolean
+ :group 'ps-print-printer)
;;; Page layout
;; B5 7.16 inch x 10.125 inch
(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'."
+ (list (list 'a4 (/ (* 72 21.0) 2.54) (/ (* 72 29.7) 2.54) "A4")
+ (list 'a3 (/ (* 72 29.7) 2.54) (/ (* 72 42.0) 2.54) "A3")
+ (list 'letter (* 72 8.5) (* 72 11.0) "Letter")
+ (list 'legal (* 72 8.5) (* 72 14.0) "Legal")
+ (list 'letter-small (* 72 7.68) (* 72 10.16) "LetterSmall")
+ (list 'tabloid (* 72 11.0) (* 72 17.0) "Tabloid")
+ (list 'ledger (* 72 17.0) (* 72 11.0) "Ledger")
+ (list 'statement (* 72 5.5) (* 72 8.5) "Statement")
+ (list 'executive (* 72 7.5) (* 72 10.0) "Executive")
+ (list 'a4small (* 72 7.47) (* 72 10.85) "A4Small")
+ (list 'b4 (* 72 10.125) (* 72 14.33) "B4")
+ (list 'b5 (* 72 7.16) (* 72 10.125) "B5"))
+ "*List associating a symbolic paper type to its width, height and doc media.
+See `ps-paper-type'."
:type '(repeat (list :tag "Paper Type"
(symbol :tag "Name")
(number :tag "Width")
- (number :tag "Height")))
- :group 'ps-print)
+ (number :tag "Height")
+ (string :tag "Media")))
+ :group 'ps-print-page)
;;;###autoload
(defcustom ps-paper-type 'letter
- "*Specifies the size of paper to format for.
+ "*Specify 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)
nil
(widget-put wid :error "Unknown paper size")
wid)))
- :group 'ps-print)
+ :group 'ps-print-page)
+
+(defcustom ps-warn-paper-type t
+ "*Non-nil means give an error if paper size is not equal to `ps-paper-type'.
+
+It's used when `ps-spool-config' is set to `setpagedevice'."
+ :type 'boolean
+ :group 'ps-print-page)
(defcustom ps-landscape-mode nil
"*Non-nil means print in landscape mode."
:type 'boolean
- :group 'ps-print)
+ :group 'ps-print-page)
+
+(defcustom ps-print-upside-down nil
+ "*Non-nil means print upside-down."
+ :type 'boolean
+ :group 'ps-print-page)
(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,
-you can send ^ and D.
+ "*Specify 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.
+ 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.
+ 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.
+ `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.
+ 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)
+ :type '(choice :menu-tag "Control Char"
+ :tag "Control Char"
+ (const 8-bit) (const control-8-bit)
+ (const control) (const :tag "nil" nil))
+ :group 'ps-print-miscellany)
+
+(defcustom ps-n-up-printing 1
+ "*Specify the number of pages per sheet paper."
+ :type '(integer
+ :tag "N Up Printing"
+ :validate
+ (lambda (wid)
+ (if (and (< 0 (widget-value wid))
+ (<= (widget-value wid) 100))
+ nil
+ (widget-put
+ wid :error
+ "Number of pages per sheet paper must be between 1 and 100.")
+ wid)))
+ :group 'ps-print-n-up)
+
+(defcustom ps-n-up-margin (/ (* 72 1.0) 2.54) ; 1 cm
+ "*Specify the margin in points between the sheet border and n-up printing."
+ :type 'number
+ :group 'ps-print-n-up)
+
+(defcustom ps-n-up-border-p t
+ "*Non-nil means a border is drawn around each page."
+ :type 'boolean
+ :group 'ps-print-n-up)
+
+(defcustom ps-n-up-filling 'left-top
+ "*Specify how page matrix is filled on each sheet of paper.
+
+Following are the valid values for `ps-n-up-filling' with a filling example
+using a 3x4 page matrix:
+
+ `left-top' 1 2 3 4 `left-bottom' 9 10 11 12
+ 5 6 7 8 5 6 7 8
+ 9 10 11 12 1 2 3 4
+
+ `right-top' 4 3 2 1 `right-bottom' 12 11 10 9
+ 8 7 6 5 8 7 6 5
+ 12 11 10 9 4 3 2 1
+
+ `top-left' 1 4 7 10 `bottom-left' 3 6 9 12
+ 2 5 8 11 2 5 8 11
+ 3 6 9 12 1 4 7 10
+
+ `top-right' 10 7 4 1 `bottom-right' 12 9 6 3
+ 11 8 5 2 11 8 5 2
+ 12 9 6 3 10 7 4 1
+
+Any other value is treated as `left-top'."
+ :type '(choice :menu-tag "N-Up Filling"
+ :tag "N-Up Filling"
+ (const left-top) (const left-bottom)
+ (const right-top) (const right-bottom)
+ (const top-left) (const bottom-left)
+ (const top-right) (const bottom-right))
+ :group 'ps-print-n-up)
(defcustom ps-number-of-columns (if ps-landscape-mode 2 1)
- "*Specifies the number of columns"
+ "*Specify the number of columns"
:type 'number
- :group 'ps-print)
+ :group 'ps-print-miscellany)
(defcustom ps-zebra-stripes nil
"*Non-nil means print zebra stripes.
-See also documentation for `ps-zebra-stripe-height'."
+See also documentation for `ps-zebra-stripe-height' and `ps-zebra-color'."
:type 'boolean
- :group 'ps-print)
+ :group 'ps-print-zebra)
(defcustom ps-zebra-stripe-height 3
"*Number of zebra stripe lines.
-See also documentation for `ps-zebra-stripes'."
+See also documentation for `ps-zebra-stripes' and `ps-zebra-color'."
:type 'number
- :group 'ps-print)
+ :group 'ps-print-zebra)
+
+(defcustom ps-zebra-color 0.95
+ "*Zebra stripe gray scale or RGB color.
+See also documentation for `ps-zebra-stripes' and `ps-zebra-stripe-height'."
+ :type '(choice :menu-tag "Zebra Gray/Color"
+ :tag "Zebra Gray/Color"
+ (number :tag "Gray Scale" :value 0.95)
+ (string :tag "Color Name" :value "gray95")
+ (list :tag "RGB Color" :value (0.95 0.95 0.95)
+ (number :tag "Red")
+ (number :tag "Green")
+ (number :tag "Blue")))
+ :group 'ps-print-zebra)
+
+(defcustom ps-zebra-stripe-follow nil
+ "*Non-nil means zebra stripe continues on next page.
+
+If `ps-zebra-stripe-follow' is nil, zebra stripe is restarted on each page.
+If `ps-zebra-stripe-follow' is non-nil, zebra stripe continues on next page.
+
+Visually, we have:
+
+ `ps-zebra-stripe-follow' `ps-zebra-stripe-follow'
+ is nil is non-nil
+ Current Page ------------------------ ------------------------
+ 1 XXXXXXXXXXXXXXXXXXXXX 1 XXXXXXXXXXXXXXXXXXXXX
+ 2 XXXXXXXXXXXXXXXXXXXXX 2 XXXXXXXXXXXXXXXXXXXXX
+ 3 XXXXXXXXXXXXXXXXXXXXX 3 XXXXXXXXXXXXXXXXXXXXX
+ 4 4
+ 5 5
+ 6 6
+ 7 XXXXXXXXXXXXXXXXXXXXX 7 XXXXXXXXXXXXXXXXXXXXX
+ 8 XXXXXXXXXXXXXXXXXXXXX 8 XXXXXXXXXXXXXXXXXXXXX
+ ------------------------ ------------------------
+ Next Page ------------------------ ------------------------
+ 9 XXXXXXXXXXXXXXXXXXXXX 9 XXXXXXXXXXXXXXXXXXXXX
+ 10 XXXXXXXXXXXXXXXXXXXXX 10
+ 11 XXXXXXXXXXXXXXXXXXXXX 11
+ 12 12
+ 13 13 XXXXXXXXXXXXXXXXXXXXX
+ 14 14 XXXXXXXXXXXXXXXXXXXXX
+ 15 XXXXXXXXXXXXXXXXXXXXX 15 XXXXXXXXXXXXXXXXXXXXX
+ 16 XXXXXXXXXXXXXXXXXXXXX 16
+ ------------------------ ------------------------"
+ :type 'boolean
+ :group 'ps-print-zebra)
(defcustom ps-line-number nil
"*Non-nil means print line number."
:type 'boolean
- :group 'ps-print)
+ :group 'ps-print-miscellany)
+
+(defcustom ps-line-number-step 1
+ "*Specify the interval that line number is printed.
+
+For example, `ps-line-number-step' is set to 2, the printing will look like:
+
+ 1 one line
+ one line
+ 3 one line
+ one line
+ 5 one line
+ one line
+ ...
+
+Valid values are:
+
+ integer an integer that specifies the interval that line number is
+ printed. If it's lesser than or equal to zero, it's used the
+ value 1.
+
+ `zebra' specifies that only the line number of the first line in a zebra
+ stripe is to be printed.
+
+Any other value is treated as `zebra'."
+ :type '(choice :menu-tag "Line Number Step"
+ :tag "Line Number Step"
+ (integer :tag "Step Interval")
+ (const :tag "Synchronize Zebra" zebra))
+ :group 'ps-print-miscellany)
+
+(defcustom ps-line-number-start 1
+ "*Specify the starting point in the interval given by `ps-line-number-step'.
+
+For example, if `ps-line-number-step' is set to 3 and `ps-line-number-start' is set to 3, the
+printing will look like:
+
+ one line
+ one line
+ 3 one line
+ one line
+ one line
+ 6 one line
+ one line
+ one line
+ 9 one line
+ one line
+ ...
+
+The values for `ps-line-number-start':
+
+ * If `ps-line-number-step' is an integer, must be between 1 and the value
+ of `ps-line-number-step' inclusive.
+
+ * If `ps-line-number-step' is set to `zebra', must be between 1 and the
+ value of `ps-zebra-strip-height' inclusive. Use this combination if you
+ wish that line number be relative to zebra stripes."
+ :type '(integer :tag "Start Step Interval")
+ :group 'ps-print-miscellany)
(defcustom ps-print-background-image nil
"*EPS image list to be printed on background.
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)
+ :type '(repeat
+ (list
+ (file :tag "EPS File")
+ (choice :tag "X" (const :tag "default" nil) number string)
+ (choice :tag "Y" (const :tag "default" nil) number string)
+ (choice :tag "X Scale" (const :tag "default" nil) number string)
+ (choice :tag "Y Scale" (const :tag "default" nil) number string)
+ (choice :tag "Rotation" (const :tag "default" nil) number string)
+ (repeat :tag "Pages" :inline t
+ (radio (integer :tag "Page")
+ (cons :tag "Range"
+ (integer :tag "From")
+ (integer :tag "To"))))))
+ :group 'ps-print-background)
(defcustom ps-print-background-text nil
"*Text list to be printed on background.
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)
+ :type '(repeat
+ (list
+ (string :tag "Text")
+ (choice :tag "X" (const :tag "default" nil) number string)
+ (choice :tag "Y" (const :tag "default" nil) number string)
+ (choice :tag "Font" (const :tag "default" nil) string)
+ (choice :tag "Fontsize" (const :tag "default" nil) number string)
+ (choice :tag "Gray" (const :tag "default" nil) number string)
+ (choice :tag "Rotation" (const :tag "default" nil) number string)
+ (repeat :tag "Pages" :inline t
+ (radio (integer :tag "Page")
+ (cons :tag "Range"
+ (integer :tag "From")
+ (integer :tag "To"))))))
+ :group 'ps-print-background)
;;; Horizontal layout
customizable by changing variables `ps-left-header' and
`ps-right-header'."
:type 'boolean
- :group 'ps-print-header)
+ :group 'ps-print-headers)
(defcustom ps-print-only-one-header nil
"*Non-nil means print only one header at the top of each page.
to have only one header over all columns or one header per column.
See also `ps-print-header'."
:type 'boolean
- :group 'ps-print-header)
+ :group 'ps-print-headers)
(defcustom ps-print-header-frame t
"*Non-nil means draw a gaudy frame around the header."
:type 'boolean
- :group 'ps-print-header)
+ :group 'ps-print-headers)
(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)
+ :group 'ps-print-headers)
+
+(defcustom ps-switch-header 'duplex
+ "*Specify if headers are switched or not.
+
+Valid values are:
+
+nil Never switch headers.
+
+t Always switch headers.
+
+duplex Switch headers only when duplexing is on, that is, when
+ `ps-spool-duplex' is non-nil.
+
+Any other value is treated as t."
+ :type '(choice :menu-tag "Switch Header"
+ :tag "Switch Header"
+ (const :tag "Never Switch" nil)
+ (const :tag "Always Switch" t)
+ (const :tag "Switch When Duplexing" duplex))
+ :group 'ps-print-headers)
(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'."
+ see variable `ps-print-header'."
:type 'boolean
- :group 'ps-print-header)
-
-(defcustom ps-spool-duplex nil ; Not many people have duplex
- ; printers, so default to 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."
+ :group 'ps-print-headers)
+
+(defcustom ps-spool-config
+ (if ps-windows-system
+ nil
+ 'lpr-switches)
+ "*Specify who is responsable for setting duplex and page size switches.
+
+Valid values are:
+
+ `lpr-switches' duplex and page size are configured by `ps-lpr-switches'.
+ Don't forget to set `ps-lpr-switches' to select duplex
+ printing for your printer.
+
+ `setpagedevice' duplex and page size are configured by ps-print using the
+ setpagedevice PostScript operator.
+
+ nil duplex and page size are configured by ps-print *not* using
+ the setpagedevice PostScript operator.
+
+Any other value is treated as nil.
+
+WARNING: The setpagedevice PostScript operator affects ghostview utility when
+ viewing file generated using landscape. Also on some printers,
+ setpagedevice affects zebra stripes; on other printers, setpagedevice
+ affects the left margin.
+ Besides all that, if your printer does not have the paper size
+ specified by setpagedevice, your printing will be aborted.
+ So, if you need to use setpagedevice, set `ps-spool-config' to
+ `setpagedevice', generate a test file and send it to your printer; if
+ the printed file isn't ok, set `ps-spool-config' to nil."
+ :type '(choice :menu-tag "Spool Config"
+ :tag "Spool Config"
+ (const lpr-switches) (const setpagedevice)
+ (const :tag "nil" nil))
+ :group 'ps-print-headers)
+
+(defcustom ps-spool-duplex nil ; Not many people have duplex printers,
+ ; so default to nil.
+ "*Non-nil generates PostScript for a two-sided printer.
+For a duplex printer, the `ps-spool-*' and `ps-print-*' 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.
+
+See also `ps-spool-tumble'."
+ :type 'boolean
+ :group 'ps-print-headers)
+
+(defcustom ps-spool-tumble nil
+ "*Specify how the page images on opposite sides of a sheet are oriented.
+If `ps-spool-tumble' is nil, produces output suitable for binding on the left or
+right. If `ps-spool-tumble' is non-nil, produces output suitable for binding at
+the top or bottom.
+
+It has effect only when `ps-spool-duplex' is non-nil."
:type 'boolean
- :group 'ps-print-header)
+ :group 'ps-print-headers)
;;; Fonts
(size . 10.0)
(line-height . 11.0)
(space-width . 2.5)
- (avg-char-width 4.71432))
+ (avg-char-width . 4.71432))
(Palatino
(fonts (normal . "Palatino-Roman")
(bold . "Palatino-Bold")
(italic . "NewCenturySchlbk-Italic")
(bold-italic . "NewCenturySchlbk-BoldItalic"))
(size . 10.0)
- (line-height 12.15)
+ (line-height . 12.15)
(space-width . 2.78)
(avg-char-width . 5.31162))
;; got no bold for the next ones
You can get all the fonts of YOUR printer using `ReportAllFontInfo'."
:type '(repeat (list :tag "Font Definition"
(symbol :tag "Font Family")
- (cons (const fonts)
- (repeat (cons (choice (const normal)
+ (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 (const size)
+ (cons :format "%v"
+ (const :format "" size)
(number :tag "Reference Size"))
- (cons (const line-height)
+ (cons :format "%v"
+ (const :format "" line-height)
(number :tag "Line Height"))
- (cons (const space-width)
+ (cons :format "%v"
+ (const :format "" space-width)
(number :tag "Space Width"))
- (cons (const avg-char-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."
+ "*Font family name for ordinary text, when generating PostScript."
:type 'symbol
:group 'ps-print-font)
-(defcustom ps-font-size (if ps-landscape-mode 7 8.5)
- "Font size, in points, for ordinary text, when generating PostScript."
- :type 'number
+(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."
+ "*Font family name for text in the header, when generating PostScript."
:type 'symbol
:group 'ps-print-font)
-(defcustom ps-header-font-size (if ps-landscape-mode 10 12)
- "Font size, in points, for text in the header, when generating PostScript."
- :type 'number
+(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 (if ps-landscape-mode 12 14)
- "Font size, in points, for the top line of text in header, in PostScript."
- :type 'number
+(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)
;;; Colors
(defcustom ps-print-color-p (or (fboundp 'x-color-values) ; Emacs
(fboundp 'color-instance-rgb-components))
; XEmacs
- "*If non-nil, print the buffer's text in color."
+ "*Non-nil means 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"))
+ :type '(choice :menu-tag "Default Foreground Gray/Color"
+ :tag "Default Foreground Gray/Color"
+ (number :tag "Gray Scale" :value 0.0)
+ (string :tag "Color Name" :value "black")
+ (list :tag "RGB Color" :value (0.0 0.0 0.0)
+ (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"))
+ :type '(choice :menu-tag "Default Background Gray/Color"
+ :tag "Default Background Gray/Color"
+ (number :tag "Gray Scale" :value 1.0)
+ (string :tag "Color Name" :value "white")
+ (list :tag "RGB Color" :value (1.0 1.0 1.0)
+ (number :tag "Red")
+ (number :tag "Green")
+ (number :tag "Blue")))
:group 'ps-print-color)
(defcustom ps-auto-font-detect t
:type '(repeat face)
:group 'ps-print-face)
+(defcustom ps-use-face-background nil
+ "*Specify if face background should be used.
+
+Valid values are:
+
+ t always use face background color.
+ nil never use face background color.
+ (face...) list of faces whose background color will be used.
+
+Any other value will be treated as t."
+ :type '(choice :menu-tag "Use Face Background"
+ :tag "Use Face Background"
+ (const :tag "Always Use Face Background" t)
+ (const :tag "Never Use Face Background" nil)
+ (repeat :menu-tag "Face Background List"
+ :tag "Face Background List"
+ 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.
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)
+ :group 'ps-print-headers)
(defcustom ps-right-header
(list "/pagenumberstring load" 'time-stamp-mon-dd-yyyy 'time-stamp-hh:mm:ss)
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)
+ :group 'ps-print-headers)
(defcustom ps-razzle-dazzle t
"*Non-nil means report progress while formatting buffer."
:type 'boolean
- :group 'ps-print)
+ :group 'ps-print-miscellany)
(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)
+ :group 'ps-print-miscellany)
(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
+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.
:type 'boolean
:group 'ps-print-face)
+(defcustom ps-banner-page-when-duplexing nil
+ "*Non-nil means the very first page is skipped.
+It's like the very first character of buffer (or region) is ^L (\\014)."
+ :type 'boolean
+ :group 'ps-print-headers)
+
+(defcustom ps-postscript-code-directory
+ (or (and (fboundp 'locate-data-directory) ; xemacs
+ (locate-data-directory "ps-print"))
+ data-directory) ; emacs
+ "*Directory where it's located the PostScript prologue file used by ps-print.
+By default, this directory is the same as in the variable `data-directory'."
+ :type 'directory
+ :group 'ps-print-miscellany)
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Customization
+
+
+;;;###autoload
+(defun ps-print-customize ()
+ "Customization of ps-print group."
+ (interactive)
+ (customize-group 'ps-print))
+
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; User commands
+
;;;###autoload
(defun ps-print-buffer (&optional filename)
"Generate and print a PostScript image of the buffer.
-When called with a numeric prefix argument (C-u), prompts the user for
-the name of a file to save the PostScript image in, instead of sending
-it to the printer.
+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.
-More specifically, the FILENAME argument is treated as follows: if it
+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. If FILENAME is a
-number, prompt the user for the name of the file to save in."
+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-despool (&optional filename)
"Send the spooled PostScript to the printer.
-When called with a numeric prefix argument (C-u), prompt the user for
-the name of a file to save the spooled PostScript in, instead of sending
-it 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.
-More specifically, the FILENAME argument is treated as follows: if it
+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. If FILENAME is a
-number, prompt the user for the name of the file to save in."
+the PostScript image in a file with that name."
(interactive (list (ps-print-preprint current-prefix-arg)))
(ps-do-despool filename))
"Return the current PostScript-generation setup."
(format
"
-\(setq ps-print-color-p %s
- ps-lpr-command \"%s\"
- ps-lpr-switches %s
-
- ps-paper-type '%s
+;;; ps-print version %s
+\(setq ps-print-color-p %s
+ ps-lpr-command %S
+ ps-lpr-switches %s
+ ps-printer-name %S
+ ps-print-region-function %s
+ ps-manual-feed %S
+
+ ps-paper-type %s
+ ps-warn-paper-type %s
ps-landscape-mode %s
+ ps-print-upside-down %s
ps-number-of-columns %s
ps-zebra-stripes %s
ps-zebra-stripe-height %s
+ ps-zebra-stripe-follow %S
+ ps-zebra-color %s
ps-line-number %s
+ ps-line-number-step %s
+ ps-line-number-start %S
+
+ ps-default-fg %s
+ ps-default-bg %s
+
+ ps-use-face-background %s
ps-print-control-characters %s
ps-print-background-text %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-header-frame %s
- ps-header-lines %s
- ps-show-n-of-n %s
- ps-spool-duplex %s
-
- ps-font-family '%s
+ ps-error-handler-message %s
+ ps-user-defined-prologue %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-switch-header %s
+ ps-header-lines %s
+ ps-show-n-of-n %s
+ ps-spool-config %s
+ ps-spool-duplex %s
+ ps-spool-tumble %s
+ ps-banner-page-when-duplexing %s
+
+ ps-n-up-printing %s
+ ps-n-up-margin %s
+ ps-n-up-border-p %s
+ ps-n-up-filling %s
+
+ ps-multibyte-buffer %s
+ ps-font-family %s
ps-font-size %s
- ps-header-font-family '%s
+ ps-header-font-family %s
ps-header-font-size %s
ps-header-title-font-size %s)
"
+ ps-print-version
ps-print-color-p
ps-lpr-command
- ps-lpr-switches
- ps-paper-type
+ (ps-print-quote ps-lpr-switches)
+ ps-printer-name
+ (ps-print-quote ps-print-region-function)
+ ps-manual-feed
+ (ps-print-quote ps-paper-type)
+ ps-warn-paper-type
ps-landscape-mode
+ ps-print-upside-down
ps-number-of-columns
ps-zebra-stripes
ps-zebra-stripe-height
+ ps-zebra-stripe-follow
+ (ps-print-quote ps-zebra-color)
ps-line-number
- ps-print-control-characters
- ps-print-background-image
- ps-print-background-text
+ (ps-print-quote ps-line-number-step)
+ ps-line-number-start
+ (ps-print-quote ps-default-fg)
+ (ps-print-quote ps-default-bg)
+ (ps-print-quote ps-use-face-background)
+ (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-error-handler-message)
+ (ps-print-quote ps-user-defined-prologue)
+ (ps-print-quote ps-print-prologue-header)
ps-left-margin
ps-right-margin
ps-inter-column
ps-header-offset
ps-header-line-pad
ps-print-header
+ ps-print-only-one-header
ps-print-header-frame
+ (ps-print-quote ps-switch-header)
ps-header-lines
ps-show-n-of-n
+ (ps-print-quote ps-spool-config)
ps-spool-duplex
- ps-font-family
- ps-font-size
- ps-header-font-family
- ps-header-font-size
- ps-header-title-font-size))
+ ps-spool-tumble
+ ps-banner-page-when-duplexing
+ ps-n-up-printing
+ ps-n-up-margin
+ ps-n-up-border-p
+ (ps-print-quote ps-n-up-filling)
+ (ps-print-quote ps-multibyte-buffer) ; see `ps-mule.el'
+ (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)))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Utility functions and variables:
+
+(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)
;; Return t if the device (which can be changed during an emacs session)
;; can handle colors.
;; This is function is not yet implemented for GNU emacs.
-(defun ps-color-device ()
- (if (and (eq ps-print-emacs-type 'xemacs)
- (>= emacs-minor-version 12))
- (eq (device-class) 'color)
- t))
+(cond ((and (eq ps-print-emacs-type 'xemacs)
+ (>= emacs-minor-version 12)) ; xemacs
+ (defun ps-color-device ()
+ (eq (device-class) 'color))
+ )
+
+ (t ; emacs
+ (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 % -- 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 0 50 FontMatrix transform exch pop def
- /Xshadow 0 80 FontMatrix transform exch pop def
- /Yshadow 0 -90 FontMatrix transform exch pop 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 {
- % ---- 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
- LandscapeMode {
- % ---- translate to bottom-right corner of Portrait page
- LandscapePageHeight 0 translate
- 90 rotate
- } if
- /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
-")
+(defun ps-prologue-file (filenumber)
+ (save-excursion
+ (let* ((filename (format "%sps-prin%d.ps"
+ ps-postscript-code-directory filenumber))
+ (buffer
+ (or (find-file-noselect filename 'no-warn 'rawfile)
+ (error "ps-print PostScript prologue `%s' file was not found."
+ filename))))
+ (set-buffer buffer)
+ (prog1
+ (buffer-string)
+ (kill-buffer buffer)))))
-(defvar ps-print-prologue-2
- "
-% ---- These lines must be kept together because...
-/h0 F
-/HeaderTitleLineHeight FontHeight def
+(defvar ps-mark-code-directory nil)
-/h1 F
-/HeaderLineHeight FontHeight def
-/HeaderDescent Descent def
+(defvar ps-print-prologue-0 ""
+ "ps-print PostScript error handler.")
-% ---- ...because `F' has a side-effect on `FontHeight' and `Descent'
+(defvar ps-print-prologue-1 ""
+ "ps-print PostScript prologue begin.")
-")
+(defvar ps-print-prologue-2 ""
+ "ps-print PostScript prologue end.")
+
+(defvar ps-print-duplex-feature ""
+ "ps-print PostScript duplex feature.")
;; Start Editing Here:
(defvar ps-output-tail nil)
(defvar ps-page-postscript 0)
+(defvar ps-page-order 0)
(defvar ps-page-count 0)
(defvar ps-showline-count 1)
(defvar ps-control-or-escape-regexp nil)
+(defvar ps-n-up-on nil)
(defvar ps-background-pages nil)
(defvar ps-background-all-pages nil)
(defvar ps-background-image-count 0)
(defvar ps-current-font 0)
-(defvar ps-default-color (if ps-print-color-p ps-default-fg)) ; black
-(defvar ps-current-color ps-default-color)
+(defvar ps-default-foreground nil)
+(defvar ps-default-color nil)
+(defvar ps-current-color nil)
(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)
(defmacro ps-page-dimensions-get-width (dims) `(nth 0 ,dims))
(defmacro ps-page-dimensions-get-height (dims) `(nth 1 ,dims))
+(defmacro ps-page-dimensions-get-media (dims) `(nth 2 ,dims))
(defvar ps-landscape-page-height 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)
+
\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Internal Variables
\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Adapted from font-lock:
+;; Adapted from font-lock: (obsolete stuff)
;; Originally face attributes were specified via `font-lock-face-attributes'.
;; Users then changed the default face attributes by setting that variable.
;; However, we try and be back-compatible and respect its value if set except
;; for faces where M-x customize has been used to save changes for the face.
+
(defun ps-font-lock-face-attributes ()
(and (boundp 'font-lock-mode) (symbol-value 'font-lock-mode)
(boundp 'font-lock-face-attributes)
(make-local-hook 'ps-print-hook)
+(make-local-hook 'ps-print-begin-sheet-hook)
(make-local-hook 'ps-print-begin-page-hook)
(make-local-hook 'ps-print-begin-column-hook)
(defun ps-spool-without-faces (from to &optional region-p)
(run-hooks 'ps-print-hook)
- (ps-printing-region region-p)
+ (ps-printing-region region-p from)
(ps-generate (current-buffer) from to 'ps-generate-postscript))
(defun ps-spool-with-faces (from to &optional region-p)
(run-hooks 'ps-print-hook)
- (ps-printing-region region-p)
+ (ps-printing-region region-p from)
(ps-generate (current-buffer) from to 'ps-generate-postscript-with-faces))
-(defsubst ps-count-lines (from to)
+(defun ps-count-lines (from to)
(+ (count-lines from to)
(save-excursion
(goto-char to)
(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.")
+ "Variable used to indicate if the region that ps-print is printing.
+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))))))
+(defvar ps-printing-region-p nil
+ "Non-nil means ps-print is printing a region.")
+
+
+(defun ps-printing-region (region-p from)
+ (setq ps-printing-region-p region-p
+ ps-printing-region
+ (cons (if region-p
+ (ps-count-lines (point-min) from)
+ 1)
+ (ps-count-lines (point-min) (point-max)))))
\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Internal functions
+
(defsubst ps-font-alist (font-sym)
(get font-sym 'fonts))
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) ; initial font size
+ (ifs ps-font-size-internal) ; initial font size
(icw (ps-avg-char-width 'ps-font-for-text)) ; initial character width
(print-width (progn (ps-get-page-dimensions)
ps-print-width))
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) ; initial font size
+ (ifs ps-font-size-internal) ; initial font size
(ilh (ps-line-height 'ps-font-for-text)) ; initial line height
(page-height (progn (ps-get-page-dimensions)
ps-print-height))
ps-number-of-columns)))
(ps-select-font ps-font-family 'ps-font-for-text
- ps-font-size ps-font-size)
+ ps-font-size-internal ps-font-size-internal)
(ps-select-font ps-header-font-family 'ps-font-for-header
- ps-header-font-size ps-header-title-font-size)
+ 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))
ps-header-pad)
ps-print-height))))
-(defun ps-print-preprint (&optional filename)
- (and filename
- (or (numberp filename)
- (listp filename))
- (let* ((name (concat (buffer-name) ".ps"))
+(defun ps-print-preprint (prefix-arg)
+ (and prefix-arg
+ (or (numberp prefix-arg)
+ (listp prefix-arg))
+ (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))))
(defun ps-output-string-prim (string)
(insert "(") ;insert start-string delimiter
(save-excursion ;insert string
- (insert string))
+ (insert (string-as-unibyte string)))
;; Find and quote special characters as necessary for PS
- ;; This skips everything except control chars, nonascii chars,
- ;; (, ) and \.
+ ;; This skips everything except control chars, non-ASCII chars, (, ) and \.
(while (progn (skip-chars-forward " -'*-[]-~") (not (eobp)))
(let ((special (following-char)))
- (if (> (char-bytes special) 1)
- (forward-char)
- (delete-char 1)
- (insert (aref ps-string-escape-codes special)))))
+ (delete-char 1)
+ (insert (aref ps-string-escape-codes special))))
(goto-char (point-max))
(insert ")")) ;insert end-string delimiter
(defun ps-output-list (the-list)
(mapcar 'ps-output the-list))
+;; Output strings in the list ARGS in the PostScript prologue part.
+(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)))
- (if (not (eq t it))
- (insert it)
+ (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))
- (ps-output-string-prim (car 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)
- ;; Check to see that the file exists and is readable; if not, throw
- ;; an error.
- (or (file-readable-p fname)
- (error "Could not read file `%s'" fname))
(save-excursion
(set-buffer ps-spool-buffer)
(goto-char (point-max))
(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)))))
+ #'(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))))
+(defconst ps-boundingbox-re
+ "^%%BoundingBox:\
+\\s-+\\([0-9.]+\\)\\s-+\\([0-9.]+\\)\\s-+\\([0-9.]+\\)\\s-+\\([0-9.]+\\)")
+
+
(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)
+ (if (re-search-forward ps-boundingbox-re nil t)
(vector (string-to-number ; lower x
(buffer-substring (match-beginning 1) (match-end 1)))
(string-to-number ; lower y
(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)) ; text
- (ps-output
- "\n"
- (ps-float-format (nth 4 text) 200.0) ; font size
- (format "/%s " (or (nth 3 text) "Times-Roman")) ; font name
- (ps-float-format (nth 6 text)
- "PrintHeight PrintPageWidth atan") ; rotation
- (ps-float-format (nth 5 text) 0.85) ; gray
- (ps-float-format (nth 1 text) "0") ; x position
- (ps-float-format (nth 2 text) "BottomMargin") ; y position
- "\nShowBackText} def\n")
- (ps-background-pages (nthcdr 7 text) ; page list
- (format "ShowBackText-%d\n"
- ps-background-text-count)))
+ #'(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)) ; text
+ (ps-output
+ "\n"
+ (ps-float-format (nth 4 text) 200.0) ; font size
+ (format "/%s " (or (nth 3 text) "Times-Roman")) ; font name
+ (ps-float-format (nth 6 text)
+ "PrintHeight PrintPageWidth atan") ; rotation
+ (ps-float-format (nth 5 text) 0.85) ; gray
+ (ps-float-format (nth 1 text) "0") ; x position
+ (ps-float-format (nth 2 text) "0") ; y position
+ "\nShowBackText} def\n")
+ (ps-background-pages (nthcdr 7 text) ; page list
+ (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) ; rotation
- (ps-float-format (nth 3 image) 1.0) ; x scale
- (ps-float-format (nth 4 image) 1.0) ; y scale
- (ps-float-format (nth 1 image) ; x position
- "PrintPageWidth 2 div")
- (ps-float-format (nth 2 image) ; y position
- "PrintHeight 2 div BottomMargin add")
- "\nBeginBackImage\n")
- (ps-insert-file image-file)
- ;; coordinate adjustment to centralize image
- ;; around x and y position
- (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) ; page list
- (format "ShowBackImage-%d\n"
- ps-background-image-count))))))
+ #'(lambda (image)
+ (let ((image-file (expand-file-name (nth 0 image))))
+ (when (file-readable-p image-file)
+ (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) ; rotation
+ (ps-float-format (nth 3 image) 1.0) ; x scale
+ (ps-float-format (nth 4 image) 1.0) ; y scale
+ (ps-float-format (nth 1 image) ; x position
+ "PrintPageWidth 2 div")
+ (ps-float-format (nth 2 image) ; y position
+ "PrintHeight 2 div BottomMargin add")
+ "\nBeginBackImage\n")
+ (ps-insert-file image-file)
+ ;; coordinate adjustment to centralize image
+ ;; around x and y position
+ (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) ; page list
+ (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)))))
+ (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"))))
(setq tail (cdr tail)))
(nreverse new)))
+
;; Find the first occurrence of ITEM in LIST.
;; Return the index of the matching item, or nil if not found.
;; Elements are compared with `eq'.
(and found index)))
+(defconst ps-n-up-database
+ '((a4
+ (1 nil 1 1 0)
+ (2 t 1 2 0)
+ (4 nil 2 2 0)
+ (6 t 2 3 1)
+ (8 t 2 4 0)
+ (9 nil 3 3 0)
+ (12 t 3 4 2)
+ (16 nil 4 4 0)
+ (18 t 3 6 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (32 t 4 8 0)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (50 t 5 10 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (a3
+ (1 nil 1 1 0)
+ (2 t 1 2 0)
+ (4 nil 2 2 0)
+ (6 t 2 3 1)
+ (8 t 2 4 0)
+ (9 nil 3 3 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (18 t 3 6 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (32 t 4 8 0)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (50 t 5 10 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (letter
+ (1 nil 1 1 0)
+ (2 t 1 2 0) ; adjusted by PostScript code
+ (4 nil 2 2 0)
+ (6 t 2 3 0)
+ (9 nil 3 3 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (36 nil 6 6 0)
+ (40 t 5 8 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (legal
+ (1 nil 1 1 0)
+ (2 t 1 2 0)
+ (4 nil 2 2 0)
+ (6 nil 3 2 1)
+ (9 nil 3 3 0)
+ (10 t 2 5 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (70 t 5 14 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (letter-small
+ (1 nil 1 1 0)
+ (2 t 1 2 0) ; adjusted by PostScript code
+ (4 nil 2 2 0)
+ (6 t 2 3 0)
+ (9 nil 3 3 0)
+ (12 t 3 4 1)
+ (15 t 3 5 0)
+ (16 nil 4 4 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (28 t 4 7 0)
+ (30 nil 6 5 1)
+ (36 nil 6 6 0)
+ (40 t 5 8 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (56 nil 8 7 1)
+ (60 t 6 10 0)
+ (64 nil 8 8 0)
+ (72 ni 9 8 1)
+ (81 nil 9 9 0)
+ (84 t 7 12 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (tabloid
+ (1 nil 1 1 0)
+ (2 t 1 2 0)
+ (4 nil 2 2 0)
+ (6 t 2 3 1)
+ (8 t 2 4 0)
+ (9 nil 3 3 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (84 t 6 14 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ ;; Ledger paper size is a special case, it is the only paper size where the
+ ;; normal size is landscaped, that is, the height is smaller than width.
+ ;; So, we use the special value `pag' in the `landscape' field.
+ (ledger
+ (1 nil 1 1 0)
+ (2 pag 1 2 0)
+ (4 nil 2 2 0)
+ (6 pag 2 3 1)
+ (8 pag 2 4 0)
+ (9 nil 3 3 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (84 pag 6 14 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (statement
+ (1 nil 1 1 0)
+ (2 t 1 2 0)
+ (4 nil 2 2 0)
+ (6 nil 3 2 1)
+ (9 nil 3 3 0)
+ (10 t 2 5 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (20 nil 5 4 1)
+ (21 t 3 7 0)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (36 nil 6 6 0)
+ (40 t 4 10 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (56 nil 8 7 1)
+ (60 t 5 12 0)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (executive
+ (1 nil 1 1 0)
+ (2 t 1 2 0) ; adjusted by PostScript code
+ (4 nil 2 2 0)
+ (6 t 2 3 0)
+ (9 nil 3 3 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (28 t 4 7 0)
+ (30 nil 6 5 1)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (45 t 5 9 0)
+ (49 nil 7 7 0)
+ (56 nil 8 7 1)
+ (60 t 6 10 0)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (84 t 7 12 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (a4small
+ (1 nil 1 1 0)
+ (2 t 1 2 0)
+ (4 nil 2 2 0)
+ (6 t 2 3 1)
+ (8 t 2 4 0)
+ (9 nil 3 3 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (18 t 3 6 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (32 t 4 8 0)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (50 t 5 10 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (78 t 6 13 0)
+ (81 nil 9 9 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (b4
+ (1 nil 1 1 0)
+ (2 t 1 2 0)
+ (4 nil 2 2 0)
+ (6 t 2 3 1)
+ (8 t 2 4 0)
+ (9 nil 3 3 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (18 t 3 6 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (32 t 4 8 0)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (50 t 5 10 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (72 nil 9 8 1)
+ (81 nil 9 9 0)
+ (90 nil 10 9 1)
+ (100 nil 10 10 0))
+ (b5
+ (1 nil 1 1 0)
+ (2 t 1 2 0)
+ (4 nil 2 2 0)
+ (6 t 2 3 1)
+ (8 t 2 4 0)
+ (9 nil 3 3 0)
+ (12 nil 4 3 1)
+ (16 nil 4 4 0)
+ (18 t 3 6 0)
+ (20 nil 5 4 1)
+ (25 nil 5 5 0)
+ (30 nil 6 5 1)
+ (32 t 4 8 0)
+ (36 nil 6 6 0)
+ (42 nil 7 6 1)
+ (49 nil 7 7 0)
+ (50 t 5 10 0)
+ (56 nil 8 7 1)
+ (64 nil 8 8 0)
+ (72 nil 9 8 0)
+ (81 nil 9 9 0)
+ (90 nil 10 9 1)
+ (98 t 7 14 0)
+ (100 nil 10 10 0)))
+ "Alist which is the page matrix database used for N-up printing.
+
+Each element has the following form:
+
+ (PAGE
+ (MAX LANDSCAPE LINES COLUMNS COL-MISSING)
+ ...)
+
+Where:
+PAGE is the page size used (see `ps-paper-type').
+MAX is the maximum elements of this page matrix.
+LANDSCAPE specifies if page matrix is landscaped, has the following valid
+ values:
+ nil the sheet is in portrait mode.
+ t the sheet is in landscape mode.
+ pag the sheet is in portrait mode and page is in landscape mode.
+LINES is the number of lines of page matrix.
+COLUMNS is the number of columns of page matrix.
+COL-MISSING is the number of columns missing to fill the sheet.")
+
+
+(defmacro ps-n-up-landscape (mat) `(nth 1 ,mat))
+(defmacro ps-n-up-lines (mat) `(nth 2 ,mat))
+(defmacro ps-n-up-columns (mat) `(nth 3 ,mat))
+(defmacro ps-n-up-missing (mat) `(nth 4 ,mat))
+
+
+(defun ps-n-up-printing ()
+ ;; force `ps-n-up-printing' be in range 1 to 100.
+ (setq ps-n-up-printing (max (min ps-n-up-printing 100) 1))
+ ;; find suitable page matrix for a given `ps-paper-type'.
+ (let ((the-list (cdr (assq ps-paper-type ps-n-up-database))))
+ (and the-list
+ (while (> ps-n-up-printing (caar the-list))
+ (setq the-list (cdr the-list))))
+ (car the-list)))
+
+
+(defconst ps-n-up-filling-database
+ '((left-top
+ "PageWidth" ; N-Up-XColumn
+ "0" ; N-Up-YColumn
+ "N-Up-End 1 sub PageWidth mul neg" ; N-Up-XLine
+ "LandscapePageHeight neg" ; N-Up-YLine
+ "N-Up-Lines" ; N-Up-Repeat
+ "N-Up-Columns" ; N-Up-End
+ "0" ; N-Up-XStart
+ "0") ; N-Up-YStart
+ (left-bottom
+ "PageWidth" ; N-Up-XColumn
+ "0" ; N-Up-YColumn
+ "N-Up-End 1 sub PageWidth mul neg" ; N-Up-XLine
+ "LandscapePageHeight" ; N-Up-YLine
+ "N-Up-Lines" ; N-Up-Repeat
+ "N-Up-Columns" ; N-Up-End
+ "0" ; N-Up-XStart
+ "N-Up-Repeat 1 sub LandscapePageHeight mul neg") ; N-Up-YStart
+ (right-top
+ "PageWidth neg" ; N-Up-XColumn
+ "0" ; N-Up-YColumn
+ "N-Up-End 1 sub PageWidth mul" ; N-Up-XLine
+ "LandscapePageHeight neg" ; N-Up-YLine
+ "N-Up-Lines" ; N-Up-Repeat
+ "N-Up-Columns" ; N-Up-End
+ "N-Up-End 1 sub PageWidth mul" ; N-Up-XStart
+ "0") ; N-Up-YStart
+ (right-bottom
+ "PageWidth neg" ; N-Up-XColumn
+ "0" ; N-Up-YColumn
+ "N-Up-End 1 sub PageWidth mul" ; N-Up-XLine
+ "LandscapePageHeight" ; N-Up-YLine
+ "N-Up-Lines" ; N-Up-Repeat
+ "N-Up-Columns" ; N-Up-End
+ "N-Up-End 1 sub PageWidth mul" ; N-Up-XStart
+ "N-Up-Repeat 1 sub LandscapePageHeight mul neg") ; N-Up-YStart
+ (top-left
+ "0" ; N-Up-XColumn
+ "LandscapePageHeight neg" ; N-Up-YColumn
+ "PageWidth" ; N-Up-XLine
+ "N-Up-End 1 sub LandscapePageHeight mul" ; N-Up-YLine
+ "N-Up-Columns" ; N-Up-Repeat
+ "N-Up-Lines" ; N-Up-End
+ "0" ; N-Up-XStart
+ "0") ; N-Up-YStart
+ (bottom-left
+ "0" ; N-Up-XColumn
+ "LandscapePageHeight" ; N-Up-YColumn
+ "PageWidth" ; N-Up-XLine
+ "N-Up-End 1 sub LandscapePageHeight mul neg" ; N-Up-YLine
+ "N-Up-Columns" ; N-Up-Repeat
+ "N-Up-Lines" ; N-Up-End
+ "0" ; N-Up-XStart
+ "N-Up-End 1 sub LandscapePageHeight mul neg") ; N-Up-YStart
+ (top-right
+ "0" ; N-Up-XColumn
+ "LandscapePageHeight neg" ; N-Up-YColumn
+ "PageWidth neg" ; N-Up-XLine
+ "N-Up-End 1 sub LandscapePageHeight mul" ; N-Up-YLine
+ "N-Up-Columns" ; N-Up-Repeat
+ "N-Up-Lines" ; N-Up-End
+ "N-Up-Repeat 1 sub PageWidth mul" ; N-Up-XStart
+ "0") ; N-Up-YStart
+ (bottom-right
+ "0" ; N-Up-XColumn
+ "LandscapePageHeight" ; N-Up-YColumn
+ "PageWidth neg" ; N-Up-XLine
+ "N-Up-End 1 sub LandscapePageHeight mul neg" ; N-Up-YLine
+ "N-Up-Columns" ; N-Up-Repeat
+ "N-Up-Lines" ; N-Up-End
+ "N-Up-Repeat 1 sub PageWidth mul" ; N-Up-XStart
+ "N-Up-End 1 sub LandscapePageHeight mul neg")) ; N-Up-YStart
+ "Alist for n-up printing initializations.
+
+Each element has the following form:
+
+ (KIND XCOL YCOL XLIN YLIN REPEAT END XSTART YSTART)
+
+Where:
+KIND is a valid value of `ps-n-up-filling'.
+XCOL YCOL are the relative position for the next column.
+XLIN YLIN are the relative position for the beginning of next line.
+REPEAT is the number of repetions for external loop.
+END is the number of repetions for internal loop and also the number of pages in
+ a row.
+XSTART YSTART are the relative position for the first page in a sheet.")
+
+
+(defun ps-n-up-filling ()
+ (cdr (or (assq ps-n-up-filling ps-n-up-filling-database)
+ (assq 'left-top ps-n-up-filling-database))))
+
+
+(defmacro ps-n-up-xcolumn (init) `(nth 0 ,init))
+(defmacro ps-n-up-ycolumn (init) `(nth 1 ,init))
+(defmacro ps-n-up-xline (init) `(nth 2 ,init))
+(defmacro ps-n-up-yline (init) `(nth 3 ,init))
+(defmacro ps-n-up-repeat (init) `(nth 4 ,init))
+(defmacro ps-n-up-end (init) `(nth 5 ,init))
+(defmacro ps-n-up-xstart (init) `(nth 6 ,init))
+(defmacro ps-n-up-ystart (init) `(nth 7 ,init))
+
+
+(defconst ps-error-handler-alist
+ '((none . 0)
+ (paper . 1)
+ (system . 2)
+ (paper-and-system . 3))
+ "Alist for error handler message")
+
+
(defun ps-begin-file ()
(ps-get-page-dimensions)
(setq ps-page-postscript 0
+ ps-page-order 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) ; Take job name from name of
+ (let ((dimensions (cdr (assq ps-paper-type ps-page-dimensions-database)))
+ (tumble (if ps-landscape-mode (not ps-spool-tumble) ps-spool-tumble))
+ (n-up (ps-n-up-printing))
+ (n-up-filling (ps-n-up-filling)))
+ (and ps-n-up-on (setq tumble (not tumble)))
+ (ps-output
+ ps-adobe-tag
+ "%%Title: " (buffer-name) ; Take job name from name of
; first buffer printed
- "\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%% DocumentFonts: Times-Roman Times-Italic "
- (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%%Pages: (atend)\n"
- "%%EndComments\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) ; not used
- (format "/InterColumn %s def\n" ps-inter-column)
-
- (format "/BottomMargin %s def\n" ps-bottom-margin)
- (format "/TopMargin %s def\n" ps-top-margin) ; not used
- (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")
-
- ;; Header fonts
- (ps-output (format "/h0 %s /%s DefFont\n" ; /h0 14 /Helvetica-Bold DefFont
- ps-header-title-font-size (ps-font 'ps-font-for-header
- 'bold))
- (format "/h1 %s /%s DefFont\n" ; /h1 12 /Helvetica DefFont
- ps-header-font-size (ps-font 'ps-font-for-header
- 'normal)))
-
- (ps-output ps-print-prologue-2)
-
- ;; Text fonts
- (let ((font (ps-font-alist 'ps-font-for-text))
- (i 0))
- (while font
- (ps-output (format "/f%d %s /%s DefFont\n"
- i
- ps-font-size
- (ps-font 'ps-font-for-text (car (car font)))))
- (setq font (cdr font)
- i (1+ i))))
-
- (ps-output "\nBeginDoc\n\n"
- "%%EndPrologue\n"))
+ "\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%%DocumentMedia: " (ps-page-dimensions-get-media dimensions)
+ (format " %d" (round (ps-page-dimensions-get-width dimensions)))
+ (format " %d" (round (ps-page-dimensions-get-height dimensions)))
+ " 0 () ()\n%%PageOrder: Ascend\n%%Pages: (atend)\n%%Requirements:"
+ (if ps-spool-duplex
+ (if tumble " duplex(tumble)\n" " duplex\n")
+ "\n"))
+
+ (ps-insert-string ps-print-prologue-header)
+
+ (ps-output "%%EndComments\n%%BeginDefaults\n%%PageMedia: "
+ (ps-page-dimensions-get-media dimensions)
+ "\n%%EndDefaults\n\n%%BeginPrologue\n\n"
+ "/languagelevel where{pop}{/languagelevel 1 def}ifelse\n"
+ (format "/ErrorMessage %s def\n\n"
+ (or (cdr (assoc ps-error-handler-message
+ ps-error-handler-alist))
+ 1)) ; send to paper
+ ps-print-prologue-0
+ "\n%%BeginProcSet: UserDefinedPrologue\n\n")
+
+ (ps-insert-string ps-user-defined-prologue)
+
+ (ps-output "\n%%EndProcSet\n\n")
+
+ (ps-output-boolean "LandscapeMode "
+ (or ps-landscape-mode
+ (eq (ps-n-up-landscape n-up) 'pag)))
+ (ps-output-boolean "UpsideDown " ps-print-upside-down)
+ (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) ; not used
+ (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 "SwitchHeader " (if (eq ps-switch-header 'duplex)
+ ps-spool-duplex
+ ps-switch-header))
+ (ps-output-boolean "ShowNofN " ps-show-n-of-n)
+ (ps-output-boolean "DuplexValue " ps-spool-duplex)
+ (ps-output-boolean "TumbleValue " tumble)
+
+ (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 "WarnPaperSize " ps-warn-paper-type)
+ (ps-output-boolean "Zebra " ps-zebra-stripes)
+ (ps-output-boolean "ZebraFollow " ps-zebra-stripe-follow)
+ (ps-output-boolean "PrintLineNumber " ps-line-number)
+ (ps-output-boolean "SyncLineZebra " (not (integerp ps-line-number-step)))
+ (ps-output (format "/PrintLineStep %d def\n"
+ (if (integerp ps-line-number-step)
+ ps-line-number-step
+ ps-zebra-stripe-height))
+ (format "/PrintLineStart %d def\n" ps-line-number-start)
+ (format "/ZebraHeight %d def\n" ps-zebra-stripe-height)
+ "/ZebraColor "
+ (ps-format-color ps-zebra-color 0.95)
+ "def\n/BackgroundColor "
+ (ps-format-color ps-default-bg 1.0)
+ "def\n/UseSetpagedevice "
+ (if (eq ps-spool-config 'setpagedevice)
+ "/setpagedevice where{pop languagelevel 2 eq}{false}ifelse"
+ "false")
+ " def\n\n/PageWidth "
+ "PrintPageWidth LeftMargin add RightMargin add def\n\n"
+ (format "/N-Up %d def\n" ps-n-up-printing))
+ (ps-output-boolean "N-Up-Landscape" (eq (ps-n-up-landscape n-up) t))
+ (ps-output-boolean "N-Up-Border " ps-n-up-border-p)
+ (ps-output (format "/N-Up-Lines %d def\n" (ps-n-up-lines n-up))
+ (format "/N-Up-Columns %d def\n" (ps-n-up-columns n-up))
+ (format "/N-Up-Missing %d def\n" (ps-n-up-missing n-up))
+ (format "/N-Up-Margin %s def\n" ps-n-up-margin)
+ "/N-Up-Repeat "
+ (if ps-landscape-mode
+ (ps-n-up-end n-up-filling)
+ (ps-n-up-repeat n-up-filling))
+ " def\n/N-Up-End "
+ (if ps-landscape-mode
+ (ps-n-up-repeat n-up-filling)
+ (ps-n-up-end n-up-filling))
+ " def\n/N-Up-XColumn " (ps-n-up-xcolumn n-up-filling)
+ " def\n/N-Up-YColumn " (ps-n-up-ycolumn n-up-filling)
+ " def\n/N-Up-XLine " (ps-n-up-xline n-up-filling)
+ " def\n/N-Up-YLine " (ps-n-up-yline n-up-filling)
+ " def\n/N-Up-XStart " (ps-n-up-xstart n-up-filling)
+ " def\n/N-Up-YStart " (ps-n-up-ystart n-up-filling) " def\n")
+
+ (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 "\n" ps-print-prologue-1)
+
+ (ps-output "\n/printGlobalBackground {\n")
+ (ps-output-list ps-background-all-pages)
+ (ps-output "} def\n/printLocalBackground {\n} def\n")
+
+ ;; Header fonts
+ (ps-output (format "/h0 %s (%s) cvn DefFont\n" ; /h0 14 /Helvetica-Bold DefFont
+ ps-header-title-font-size-internal
+ (ps-font 'ps-font-for-header 'bold))
+ (format "/h1 %s (%s) cvn DefFont\n" ; /h1 12 /Helvetica DefFont
+ ps-header-font-size-internal
+ (ps-font 'ps-font-for-header 'normal)))
+
+ (ps-output "\n" ps-print-prologue-2 "\n")
+
+ ;; Text fonts
+ (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\n")
+ (unless (eq ps-spool-config 'lpr-switches)
+ (ps-output "\n%%BeginFeature: *Duplex "
+ (ps-boolean-capitalized ps-spool-duplex)
+ " *Tumble "
+ (ps-boolean-capitalized tumble)
+ "\n\n"
+ ps-print-duplex-feature
+ "\n%%EndFeature\n")))
+ (ps-output "\n%%BeginFeature: *ManualFeed "
+ (ps-boolean-capitalized ps-manual-feed)
+ "\nBMark /ManualFeed "
+ (ps-boolean-constant ps-manual-feed)
+ " EMark setpagedevice\n%%EndFeature\n"
+ "\n/Lines 0 def\n/PageCount 0 def\n\nBeginDoc\n%%EndSetup\n")
+ (and ps-banner-page-when-duplexing
+ (ps-output "\n%%Page: banner 0\nsave showpage restore\n")))
+
+
+(defun ps-format-color (color &optional default)
+ (let ((the-color (if (stringp color)
+ (ps-color-scale color)
+ color)))
+ (if (and the-color (listp the-color))
+ (concat "["
+ (format ps-color-format
+ (nth 0 the-color)
+ (nth 1 the-color)
+ (nth 2 the-color))
+ "] ")
+ (ps-float-format (if (numberp the-color) the-color default)))))
+
+
+(defun ps-insert-string (prologue)
+ (let ((str (if (functionp prologue)
+ (funcall prologue)
+ prologue)))
+ (and (stringp str)
+ (ps-output str))))
+
+
+(defun ps-boolean-capitalized (bool)
+ (if bool "True" "False"))
+
+
+(defun ps-boolean-constant (bool)
+ (if bool "true" "false"))
+
(defun ps-header-dirpart ()
(let ((fname (buffer-file-name)))
(if fname
(if (string-equal (buffer-name) (file-name-nondirectory fname))
- (file-name-directory fname)
+ (abbreviate-file-name (file-name-directory fname))
fname)
"")))
+
(defun ps-get-buffer-name ()
(cond
;; Indulge Jim this little easter egg:
((string= (buffer-name) "sokoban.el")
"Super! C'est sokoban.el!")
(t (concat
- (and ps-printing-region "Subset of: ")
+ (and ps-printing-region-p "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 ()
+ (let ((last-char (aref ps-postscript-code-directory
+ (1- (length ps-postscript-code-directory)))))
+ (or (eq last-char ?/)
+ (and ps-windows-system (eq last-char ?\\))
+ (setq ps-postscript-code-directory
+ (concat ps-postscript-code-directory "/"))))
+ (or (equal ps-mark-code-directory ps-postscript-code-directory)
+ (setq ps-print-prologue-0 (ps-prologue-file 0)
+ ps-print-prologue-1 (ps-prologue-file 1)
+ ps-print-prologue-2 (ps-prologue-file 2)
+ ps-print-duplex-feature (ps-prologue-file 3)
+ ps-mark-code-directory ps-postscript-code-directory))
+ (or (listp ps-use-face-background)
+ (setq ps-use-face-background t))
+ (and (integerp ps-line-number-step)
+ (<= ps-line-number-step 0)
+ (setq ps-line-number-step 1))
+ (setq ps-n-up-on (> ps-n-up-printing 1)
+ ps-line-number-start (max 1 (min ps-line-number-start
+ (if (integerp ps-line-number-step)
+ ps-line-number-step
+ ps-zebra-stripe-height))))
(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)
+ (setq ps-showline-count (car ps-printing-region)
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)
- "[\000-\037\177-\377]")
+ (string-as-unibyte "[\000-\037\177-\377]"))
((eq ps-print-control-characters 'control-8-bit)
- "[\000-\037\177-\237]")
+ (string-as-unibyte "[\000-\037\177-\237]"))
((eq ps-print-control-characters 'control)
"[\000-\037\177]")
- (t "[\t\n\f]"))))
+ (t "[\t\n\f]"))
+ ps-default-foreground (ps-rgb-color ps-default-fg 0.0)
+ ps-default-color (and ps-print-color-p ps-default-foreground)
+ ps-current-color ps-default-color
+ ;; Set the color scale. We do it here instead of in the defvar so
+ ;; that ps-print can be dumped into emacs. This expression can't be
+ ;; evaluated at dump-time because X isn't initialized.
+ 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)))
+
+
+(defun ps-rgb-color (color default)
+ (cond ((and color (listp color)) color)
+ ((stringp color) (ps-color-scale color))
+ ((numberp color) (list color color color))
+ (t (list default default default))
+ ))
+
(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)
+(defun ps-end-file (needs-begin-file)
+ (ps-flush-output)
+ ;; Back to the PS output buffer to set the last page n-up printing
+ (save-excursion
+ (let ((pages-per-sheet (mod ps-page-postscript ps-n-up-printing))
+ case-fold-search)
+ (set-buffer ps-spool-buffer)
+ (goto-char (point-max))
+ (and (> pages-per-sheet 0)
+ (re-search-backward "^[0-9]+ BeginSheet$" nil t)
+ (replace-match (format "%d BeginSheet" pages-per-sheet) t))))
+ ;; Set dummy page
+ (and ps-spool-duplex (= (mod ps-page-order 2) 1)
+ (ps-dummy-page))
+ ;; Set end of PostScript file
+ (ps-output "EndSheet\n\n%%Trailer\n%%Pages: "
+ (format "%d"
+ (if (and needs-begin-file ps-banner-page-when-duplexing)
+ (1+ ps-page-order)
+ ps-page-order))
"\n\nEndDoc\n\n%%EOF\n"))
(ps-flush-output)
(ps-begin-page))
-(defun ps-header-page ()
+
+(defun ps-header-sheet ()
+ ;; Print only when a new sheet begins.
+ (setq ps-page-postscript (1+ ps-page-postscript)
+ ps-page-order (1+ ps-page-order))
+ (and (> ps-page-order 1)
+ (ps-output "EndSheet\n"))
+ (ps-output (if ps-n-up-on
+ (format "\n%%%%Page: (%d \\(%d\\)) %d\n"
+ ps-page-order ps-page-postscript ps-page-order)
+ (format "\n%%%%Page: %d %d\n"
+ ps-page-postscript ps-page-order))
+ (format "%d BeginSheet\nBeginDSCPage\n" ps-n-up-printing)))
+
+
+(defsubst ps-header-page ()
;; set total line and page number when printing has finished
;; (see `ps-generate')
- (if (prog1
- (zerop (mod ps-page-count ps-number-of-columns))
- (setq ps-page-count (1+ ps-page-count)))
- ;; Print only when a new real page begins.
- (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))
- ;; Print when any other page begins.
- (ps-output "/Lines 0 def\n/PageCount 0 def\nBeginDSCPage\n")
- (run-hooks 'ps-print-begin-column-hook)))
+ (run-hooks
+ (if (prog1
+ (zerop (mod ps-page-count ps-number-of-columns))
+ (setq ps-page-count (1+ ps-page-count)))
+ (prog1
+ (if (zerop (mod ps-page-postscript ps-n-up-printing))
+ ;; Print only when a new sheet begins.
+ (progn
+ (ps-header-sheet)
+ 'ps-print-begin-sheet-hook)
+ ;; Print only when a new page begins.
+ (setq ps-page-postscript (1+ ps-page-postscript))
+ (ps-output "BeginDSCPage\n")
+ 'ps-print-begin-page-hook)
+ (ps-background ps-page-postscript))
+ ;; Print only when a new column begins.
+ (ps-output "BeginDSCPage\n")
+ 'ps-print-begin-column-hook)))
(defun ps-begin-page ()
(ps-get-page-dimensions)
(ps-output "BeginPage\n")
(ps-set-font ps-current-font)
(ps-set-bg ps-current-bg)
- (ps-set-color ps-current-color))
+ (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)
+ (let ((ps-n-up-printing 0))
+ (ps-header-sheet))
(ps-output "/PrintHeader false def
+/ColumnIndex 0 def
+/PrintLineNumber false def
BeginPage
EndPage
-EndDSCPage\n"))
+EndDSCPage\n")
+ (setq ps-page-postscript ps-n-up-printing))
(defun ps-next-line ()
(setq ps-showline-count (1+ ps-showline-count))
(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))
(/ q-done (/ q-todo 100)))
))))))
+(defvar ps-last-font nil)
+
(defun ps-set-font (font)
- (ps-output (format "/f%d F\n" (setq ps-current-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 "false BG\n")))
(defun ps-set-color (color)
- (setq ps-current-color (or color ps-default-fg))
+ (setq ps-current-color (or color ps-default-foreground))
(ps-output (format ps-color-format
(nth 0 ps-current-color)
(nth 1 ps-current-color) (nth 2 ps-current-color))
;; pagefeeds, control characters, and plot each chunk.
(while (< from to)
(if (re-search-forward ps-control-or-escape-regexp to t)
- ;; region with some control characters
+ ;; region with some control characters or some multi-byte characters
(let* ((match-point (match-beginning 0))
- (match (char-after match-point)))
- (ps-plot 'ps-basic-plot-string from (1- (point)) bg-color)
+ (match (char-after match-point))
+ (composition (find-composition from (1+ match-point))))
+ (if composition
+ (if (and (nth 2 composition)
+ (<= (car composition) match-point))
+ (progn
+ (setq match-point (car composition)
+ match 0)
+ (goto-char (nth 1 composition)))
+ (setq composition nil)))
+ (when (< from match-point)
+ (ps-mule-set-ascii-font)
+ (ps-plot 'ps-basic-plot-string from match-point bg-color))
(cond
((= match ?\t) ; tab
- (let ((linestart (save-excursion (beginning-of-line) (point))))
+ (let ((linestart (line-beginning-position)))
(forward-char -1)
(setq from (+ linestart (current-column)))
- (if (re-search-forward "[ \t]+" to t)
- (ps-plot 'ps-basic-plot-whitespace
- from (+ linestart (current-column))
- bg-color))))
+ (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) ; newline
(ps-next-line))
(or (and (= (char-after (1- match-point)) ?\n)
(= ps-height-remaining ps-print-height))
(ps-next-page)))
+
+ (composition ; a composite sequence
+ (ps-plot 'ps-mule-plot-composition match-point (point) bg-color))
+
; characters from ^@ to ^_ and
+ ((> match 255) ; a multi-byte character
+ (let* ((charset (char-charset match))
+ (composition (find-composition match-point to))
+ (stop (if (nth 2 composition) (car composition) to)))
+ (or (eq charset 'composition)
+ (while (and (< (point) stop) (eq (charset-after) charset))
+ (forward-char 1)))
+ (ps-plot 'ps-mule-plot-string match-point (point) bg-color)))
+
(t ; characters from 127 to 255
(ps-control-character match)))
(setq from (point)))
- ;; region without control characters
+ ;; region without control characters nor multi-byte characters
+ (ps-mule-set-ascii-font)
(ps-plot 'ps-basic-plot-string from to bg-color)
(setq from to)))))
(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)
+(defun ps-color-scale (color)
;; Scale 16-bit X-COLOR-VALUE to PostScript color value in [0, 1] interval.
- (/ x-color-value ps-print-color-scale))
-
-(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."))))
+ (mapcar #'(lambda (value) (/ value ps-print-color-scale))
+ (ps-color-values color)))
+
+
+(defun ps-xemacs-color-name (color)
+ (if (color-specifier-p color)
+ (color-name color)
+ color))
+
+
+(cond ((eq ps-print-emacs-type 'emacs) ; 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.")))
+ )
+ ; xemacs
+ ; lucid
+ (t ; epoch
+ (defun ps-color-values (x-color)
+ (let ((color (ps-xemacs-color-name x-color)))
+ (cond
+ ((fboundp 'x-color-values)
+ (x-color-values 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 color))))
+ (t
+ (error "No available function to determine X color values.")))))
+ ))
(defun ps-face-attributes (face)
new-face))))
+(defun ps-face-background (face background)
+ (and (or (eq ps-use-face-background t)
+ (cond ((symbolp face)
+ (memq face ps-use-face-background))
+ ((listp face)
+ (let (ok)
+ (while face
+ (if (memq (car face) ps-use-face-background)
+ (setq face nil
+ ok t)
+ (setq face (cdr face))))
+ ok))
+ (t
+ nil)
+ ))
+ background))
+
+
(defun ps-face-attribute-list (face-or-list)
(if (listp face-or-list)
;; list of faces
(let ((effects 0)
- foreground background face-attr)
+ foreground background face-attr face)
(while face-or-list
- (setq face-attr (ps-face-attributes (car face-or-list))
- effects (logior effects (aref face-attr 0)))
+ (setq face (car face-or-list)
+ face-or-list (cdr face-or-list)
+ face-attr (ps-face-attributes face)
+ 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)))
+ (or background
+ (setq background (ps-face-background face (aref face-attr 2)))))
(vector effects foreground background))
;; simple face
(ps-face-attributes face-or-list)))
(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-print-color-p foreground (ps-color-device))
- (mapcar 'ps-color-value
- (ps-color-values foreground))
+ (background (ps-face-background face (aref face-bit 2)))
+ (fg-color (if (and ps-color-p foreground)
+ (ps-color-scale foreground)
ps-default-color))
- (bg-color (and ps-print-color-p background (ps-color-device)
- (mapcar 'ps-color-value
- (ps-color-values background)))))
+ (bg-color (and ps-color-p background
+ (ps-color-scale background))))
(ps-plot-region
from to
(ps-font-number 'ps-font-for-text
(goto-char to))
-(defun ps-xemacs-face-kind-p (face kind kind-regex kind-list)
+(defun ps-xemacs-face-kind-p (face kind kind-regex)
(let* ((frame-font (or (face-font-instance face)
(face-font-instance 'default)))
(kind-cons (and frame-font
- (assq kind (font-instance-properties 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))
- ;; Kludge-compatible:
- (memq face kind-list))))
+ (and kind-spec (string-match kind-regex kind-spec))))
-(defun ps-face-bold-p (face)
- (if (eq ps-print-emacs-type 'emacs)
- (or (face-bold-p face)
- (memq face ps-bold-faces))
- (ps-xemacs-face-kind-p face 'WEIGHT_NAME "bold\\|demibold" ps-bold-faces)))
-(defun ps-face-italic-p (face)
- (if (eq ps-print-emacs-type 'emacs)
- (or (face-italic-p face)
- (memq face ps-italic-faces))
- (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))))
+(cond ((eq ps-print-emacs-type 'emacs) ; emacs
+
+ (defalias 'ps-face-foreground-name 'face-foreground)
+ (defalias 'ps-face-background-name 'face-background)
+
+ (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)))
+ )
+ ; xemacs
+ ; lucid
+ (t ; epoch
+ (defun ps-face-foreground-name (face)
+ (ps-xemacs-color-name (face-foreground face)))
+
+ (defun ps-face-background-name (face)
+ (ps-xemacs-color-name (face-background face)))
+
+ (defun ps-face-bold-p (face)
+ (or (ps-xemacs-face-kind-p face 'WEIGHT_NAME "bold\\|demibold")
+ (memq face ps-bold-faces))) ; Kludge-compatible
+
+ (defun ps-face-italic-p (face)
+ (or (ps-xemacs-face-kind-p face 'ANGLE_NAME "i\\|o")
+ (ps-xemacs-face-kind-p face 'SLANT "i\\|o")
+ (memq face ps-italic-faces))) ; Kludge-compatible
+ ))
+
(defun ps-face-underlined-p (face)
(or (face-underline-p face)
(vector (logior (if (ps-face-bold-p face) 1 0) ; bold
(if (ps-face-italic-p face) 2 0) ; italic
(if (ps-face-underlined-p face) 4 0)) ; underline
- (face-foreground face)
- (face-background face))))
+ (ps-face-foreground-name face)
+ (ps-face-background-name face))))
-(defun ps-mapper (extent list)
- (nconc list (list (list (extent-start-position extent) 'push extent)
- (list (extent-end-position extent) 'pull extent)))
- nil)
+(cond ((not (eq ps-print-emacs-type 'emacs))
+ ; xemacs
+ ; lucid
+ ; epoch
+ (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-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)
- (if (fboundp 'lazy-lock-fontify-region)
- (lazy-lock-fontify-region start end) ; the new
- (lazy-lock-fontify-buffer)))) ; the old
+ (lazy-lock-fontify-region start end)))
(defun ps-generate-postscript-with-faces (from to)
;; Some initialization...
(setq ps-current-effect 0)
;; Build the reference lists of faces if necessary.
- (if (or ps-always-build-face-reference
- ps-build-face-reference)
- (progn
- (message "Collecting face information...")
- (ps-build-reference-face-lists)))
- ;; Set the color scale. We do it here instead of in the defvar so
- ;; that ps-print can be dumped into emacs. This expression can't be
- ;; evaluated at dump-time because X isn't initialized.
- (setq ps-print-color-scale
- (if (and ps-print-color-p (ps-color-device))
- (float (car (ps-color-values "white")))
- 1.0))
+ (when (or ps-always-build-face-reference
+ ps-build-face-reference)
+ (message "Collecting face information...")
+ (ps-build-reference-face-lists))
;; Generate some PostScript.
(save-restriction
(narrow-to-region from to)
+ (ps-print-ensure-fontified from to)
(let ((face 'default)
(position to))
- (ps-print-ensure-fontified from to)
(cond
- ((or (eq ps-print-emacs-type 'lucid)
- (eq ps-print-emacs-type 'xemacs))
+ ((memq ps-print-emacs-type '(xemacs lucid))
;; Build the list of extents...
(let ((a (cons 'dummy nil))
record type extent extent-list)
(cond
((eq type 'push)
- (if (extent-face extent)
- (setq extent-list (sort (cons extent extent-list)
- 'ps-extent-sorter))))
+ (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)
-
+ (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))
+ (overlay-change from)
+ (save-buffer-invisibility-spec buffer-invisibility-spec)
+ (buffer-invisibility-spec nil))
(while (< from to)
- (if (< property-change to) ; Don't search for property change
+ (and (< property-change to) ; Don't search for property change
; unless previous search succeeded.
- (setq property-change
- (next-property-change from nil to)))
- (if (< overlay-change to) ; Don't search for overlay change
+ (setq property-change (next-property-change from nil to)))
+ (and (< overlay-change to) ; Don't search for overlay change
; unless previous search succeeded.
- (setq overlay-change
- (min (next-overlay-change from) to)))
- (setq position
- (min property-change overlay-change))
+ (setq overlay-change (min (next-overlay-change from) to)))
+ (setq position (min property-change overlay-change))
;; The code below is not quite correct,
;; because a non-nil overlay invisible property
;; which is inactive according to the current value
(cond ((let ((prop (get-text-property from 'invisible)))
;; Decide whether this invisible property
;; really makes the text invisible.
- (if (eq buffer-invisibility-spec t)
+ (if (eq save-buffer-invisibility-spec t)
(not (null prop))
- (or (memq prop buffer-invisibility-spec)
- (assq prop buffer-invisibility-spec))))
+ (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)) ; text-property
- (while overlays
+ (while (and overlays
+ (not (eq face 'emacs--invisible--face)))
(let* ((overlay (car overlays))
- (overlay-face (overlay-get overlay 'face))
(overlay-invisible (overlay-get overlay 'invisible))
- (overlay-priority (or (overlay-get overlay
- 'priority)
+ (overlay-priority (or (overlay-get overlay 'priority)
0)))
- (and (or overlay-invisible overlay-face)
- (> overlay-priority face-priority)
- (setq face (cond ((if (eq buffer-invisibility-spec t)
- (not (null overlay-invisible))
- (or (memq overlay-invisible
- buffer-invisibility-spec)
- (assq overlay-invisible
- buffer-invisibility-spec)))
- nil)
- ((and face overlay-face)))
+ (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))))
;; Plot up to this record.
(narrow-to-region from to)
(and ps-razzle-dazzle
(message "Formatting...%3d%%" (setq ps-razchunk 0)))
- (set-buffer buffer)
(setq ps-source-buffer buffer
ps-spool-buffer (get-buffer-create ps-spool-buffer-name))
(ps-init-output-queue)
(progn
(set-buffer ps-spool-buffer)
(set-buffer-multibyte nil)
+
;; Get a marker and make it point to the current end of the
;; buffer, If an error occurs, we'll delete everything from
;; the end of this marker onwards.
(setq needs-begin-file t))
(save-excursion
(set-buffer ps-source-buffer)
- (if needs-begin-file (ps-begin-file))
(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)
-
- ;; Back to the PS output buffer to set the page count
- (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)))
+ (ps-end-file needs-begin-file)
+ (ps-end-job)
;; Setting this variable tells the unwind form that the
;; the PostScript was generated without error.
(and ps-razzle-dazzle (message "Formatting...done"))))))
+
+(defun ps-end-job ()
+ (ps-flush-output)
+ (let ((total-lines (cdr ps-printing-region))
+ (total-pages (if ps-print-only-one-header
+ (ps-page-number)
+ ps-page-count))
+ case-fold-search)
+ (set-buffer ps-spool-buffer)
+ ;; Back to the PS output buffer to set the page count
+ (goto-char (point-min))
+ (and (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))))
+
+
+(defvar ps-printer-name-option
+ (cond (ps-windows-system
+ "-P")
+ (ps-lp-system
+ "-d")
+ (t
+ "-P" )))
+
+
;; Permit dynamic evaluation at print time of `ps-lpr-switches'.
(defun ps-do-despool (filename)
(if (or (not (boundp 'ps-spool-buffer))
(save-excursion
(set-buffer ps-spool-buffer)
(let* ((coding-system-for-write 'raw-text-unix)
- (ps-printer-name (or ps-printer-name printer-name))
+ (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)))
- (if (and (memq system-type '(ms-dos windows-nt))
- (or (and (boundp 'dos-ps-printer)
- (stringp (symbol-value 'dos-ps-printer)))
- (stringp (symbol-value 'ps-printer-name))))
- (write-region (point-min) (point-max)
- (or (and (boundp 'dos-ps-printer)
- (stringp (symbol-value 'dos-ps-printer))
- (symbol-value 'dos-ps-printer))
- (symbol-value 'ps-printer-name))
- t 0)
- (apply 'call-process-region
- (point-min) (point-max) ps-lpr-command nil
- (and (fboundp 'start-process) 0)
- nil
- (ps-flatten-list ; dynamic evaluation
- (mapcar 'ps-eval-switch ps-lpr-switches))))))
+ (append (and (stringp ps-printer-name)
+ (list (concat ps-printer-name-option
+ 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 ; dynamic evaluation
+ (mapcar 'ps-eval-switch ps-lpr-switches)))))
(and ps-razzle-dazzle (message "Printing...done")))
(kill-buffer ps-spool-buffer)))
(not (yes-or-no-p "Unprinted PostScript waiting; exit anyway? "))
(error "Unprinted PostScript"))))
-(if (fboundp 'add-hook)
- (funcall 'add-hook 'kill-emacs-hook 'ps-kill-emacs-check)
- (if kill-emacs-hook
- (message "Won't override existing kill-emacs-hook")
- (setq kill-emacs-hook 'ps-kill-emacs-check)))
+(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)))
+\f
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Sample Setup Code:
+
;; This stuff is for anybody that's brave enough to look this far,
;; and able to figure out how to use it. It isn't really part of
;; ps-print, but I'll leave it here in hopes it might be useful:
-;; WARNING!!! The following code is *sample* code only. Don't use it
-;; unless you understand what it does!
+;; WARNING!!! The following code is *sample* code only.
+;; Don't use it unless you understand what it does!
(defmacro ps-prsc ()
`(if (eq ps-print-emacs-type 'emacs) [f22] 'f22))
(save-excursion
(goto-char (point-min))
(if (re-search-forward "^Subject:[ \t]+\\(.*\\)$" nil t)
- (buffer-substring-no-properties (match-beginning 1) (match-end 1))
+ (buffer-substring (match-beginning 1) (match-end 1))
"Subject ???")))
;; Look in an article or mail message for the From: line. Sorta-kinda
(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))))
+ (let ((fromstring (buffer-substring (match-beginning 1) (match-end 1))))
(cond
;; Try first to match addresses that look like
(substring fromstring (match-beginning 1) (match-end 1)))
;; Next try to match addresses that look like
- ;; Jim Thompson <thompson@wg2.waii.com>
- ((string-match "\\(.*\\)[ \t]+<.*>" fromstring)
- (substring fromstring (match-beginning 1) (match-end 1)))
+ ;; Jim Thompson <thompson@wg2.waii.com> or
+ ;; "Jim Thompson" <thompson@wg2.waii.com>
+ ((string-match "\\(\"?\\)\\(.*\\)\\1[ \t]+<.*>" fromstring)
+ (substring fromstring (match-beginning 2) (match-end 2)))
;; Couldn't find a real name -- show the address instead.
(t fromstring)))
(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))
+ (buffer-substring (match-beginning 1) (match-end 1))
"File ???")))
;; Look in an article or mail message for the Subject: line. To be
(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))
+ (buffer-substring (match-beginning 1) (match-end 1))
"Node ???")))
(defun ps-info-mode-hook ()
ps-header-title-font-size 8)
'ps-jack-setup)
+\f
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; To make this file smaller, some commands go in a separate file.
+;; But autoload them here to make the separation invisible.
+
+(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.")
+
+\f
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
(provide 'ps-print)
;;; ps-print.el ends here