;;; 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, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
;; Author: Jim Thompson (was <thompson@wg2.waii.com>)
;; Author: Jacques Duthen (was <duthen@cegelec-red.fr>)
;; 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: print, PostScript
-;; Time-stamp: <98/10/13 15:42:23 vinicius>
-;; Version: 4.1.1
+;; Keywords: wp, print, PostScript
+;; Time-stamp: <99/07/03 20:16:48 vinicius>
+;; Version: 5.0
-(defconst ps-print-version "4.1.1"
- "ps-print.el, v 4.1.1 <98/10/13 vinicius>
+(defconst ps-print-version "5.0"
+ "ps-print.el, v 5.0 <99/07/03 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,
;;; Commentary:
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; About ps-print
;; --------------
;; Using ps-print
;; --------------
;;
-;; The Commands
-;;
;; ps-print provides eight commands for generating PostScript images
;; of Emacs buffers:
;;
;; 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' determine the name of a local printer for
+;; 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
;; `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 Page Layout
;; ---------------
;; 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
+;; `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.
;; 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
;; Printing Multi-byte Buffer
;; --------------------------
;;
-;; The variable `ps-multibyte-buffer' specifies the ps-print multi-byte buffer
-;; handling.
-;;
-;; Valid values for `ps-multibyte-buffer' are:
-;;
-;; nil This is the value to use when you are printing
-;; buffer with only ASCII and Latin characters.
-;;
-;; `non-latin-printer' This is the value to use when you have a japanese
-;; or korean PostScript printer and want to print
-;; buffer with ASCII, Latin-1, Japanese (JISX0208 and
-;; JISX0201-Kana) and Korean characters. At present,
-;; it was not tested the Korean characters printing.
-;; If you have a korean PostScript printer, please,
-;; test it.
-;;
-;; `bdf-font' This is the value to use when you want to print
-;; buffer with BDF fonts. BDF fonts include both latin
-;; and non-latin fonts. BDF (Bitmap Distribution
-;; Format) is a format used for distributing X's font
-;; source file. BDF fonts are included in
-;; `intlfonts-1.1' which is a collection of X11 fonts
-;; for all characters supported by Emacs. In order to
-;; use this value, be sure to have installed
-;; `intlfonts-1.1' and set the variable
-;; `bdf-directory-list' appropriately (see bdf.el for
-;; documentation of this variable).
-;;
-;; `bdf-font-except-latin' This is like `bdf-font' except that it is used
-;; PostScript default fonts to print ASCII and Latin-1
-;; characters. This is convenient when you want or
-;; need to use both latin and non-latin characters on
-;; the same buffer. See `ps-font-family',
-;; `ps-header-font-family' and `ps-font-info-database'.
+;; See ps-mule.el for documentation.
;;
-;; Any other value is treated as nil.
-;;
-;; The default is nil.
+;; See ps-print-def.el for definition.
;;
;;
;; Line Number
;; 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-gray' controls the zebra stripes gray scale.
+;; It should be a float number between 0.0 (black color) and 1.0 (white color).
+;; The default is 0.95.
+;;
;; See also section How Ps-Print Has A Text And/Or Image On Background.
;;
;;
;; 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
;;
;; 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)
;;
;; New since version 2.8
;; ---------------------
;;
+;; [vinicius] 990703 Vinicius Jose Latorre <vinicius@cpqd.com.br>
+;;
+;; Better customization.
+;; `ps-banner-page-when-duplexing' and `ps-zebra-gray'.
+;;
+;; [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.
;; Things to change
;; ----------------
;;
-;; 2-up and 4-up capabilities.
;; Avoid page break inside a paragraph.
;; Add `ps-non-bold-faces' and `ps-non-italic-faces' (should be easy).
;; Improve the memory management for big files (hard?).
;; interest.
;;
;; Jim
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Code:
(unless (featurep 'lisp-float-type)
(error "`ps-print' requires floating point support"))
+;; For Emacs 20.2 and the earlier version.
+(eval-and-compile
+ (and (boundp 'mule-version) ; only if mule package is loaded
+ (string< mule-version "4.0")
+ (progn
+ (defun set-buffer-multibyte (arg)
+ (setq enable-multibyte-characters arg))
+ (defun string-as-unibyte (arg) arg)
+ (defun string-as-multibyte (arg) arg)
+ (defun charset-after (&optional arg)
+ (char-charset (char-after arg))))))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 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"
:group 'ps-print
:group 'faces)
+(defgroup ps-print-n-up nil
+ "N-up customization"
+ :prefix "ps-"
+ :tag "N-Up"
+ :group 'ps-print)
-(defcustom ps-multibyte-buffer nil
- "*Specifies the multi-byte buffer handling.
+(defgroup ps-print-zebra nil
+ "Zebra customization"
+ :prefix "ps-"
+ :tag "Zebra"
+ :group 'ps-print)
-Valid values are:
+(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)
- nil This is the value to use when you are printing
- buffer with only ASCII and Latin characters.
-
- `non-latin-printer' This is the value to use when you have a japanese
- or korean PostScript printer and want to print
- buffer with ASCII, Latin-1, Japanese (JISX0208 and
- JISX0201-Kana) and Korean characters. At present,
- it was not tested the Korean characters printing.
- If you have a korean PostScript printer, please,
- test it.
-
- `bdf-font' This is the value to use when you want to print
- buffer with BDF fonts. BDF fonts include both latin
- and non-latin fonts. BDF (Bitmap Distribution
- Format) is a format used for distributing X's font
- source file. BDF fonts are included in
- `intlfonts-1.1' which is a collection of X11 fonts
- for all characters supported by Emacs. In order to
- use this value, be sure to have installed
- `intlfonts-1.1' and set the variable
- `bdf-directory-list' appropriately (see bdf.el for
- documentation of this variable).
-
- `bdf-font-except-latin' This is like `bdf-font' except that it is used
- PostScript default fonts to print ASCII and Latin-1
- characters. This is convenient when you want or
- need to use both latin and non-latin characters on
- the same buffer. See `ps-font-family',
- `ps-header-font-family' and `ps-font-info-database'.
+(defgroup ps-print-page nil
+ "Page customization"
+ :prefix "ps-"
+ :tag "Page"
+ :group 'ps-print)
+
+
+(require 'ps-vars) ; Common definitions
-Any other value is treated as nil."
- :type '(choice (const non-latin-printer) (const bdf-font)
- (const bdf-font-except-latin) (other :tag "nil" nil))
- :group 'ps-print-font)
(defcustom ps-print-prologue-header nil
"*PostScript prologue header comments besides that ps-print generates.
PostScript Language Reference Manual (2nd edition)
Adobe Systems Incorporated
Appendix G: Document Structuring Conventions -- Version 3.0"
- :type '(choice string symbol (other :tag "nil" nil))
+ :type '(choice :tag "Prologue Header"
+ string symbol (other :tag "nil" nil))
:group 'ps-print)
-(defcustom ps-printer-name printer-name
+(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 :tag "Printer Name"
+ file (other :tag "Pipe to ps-lpr-command" pipe))
+ :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)
+ :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)
;;; 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-landscape-mode nil
"*Non-nil means print in landscape mode."
:type 'boolean
- :group 'ps-print)
+ :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,
+ "*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:
current font.
Any other value is treated as nil."
- :type '(choice (const 8-bit) (const control-8-bit)
+ :type '(choice :tag "Control Char"
+ (const 8-bit) (const control-8-bit)
(const control) (other :tag "nil" nil))
:group 'ps-print)
+(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 :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)
(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-gray'."
: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-gray'."
:type 'number
- :group 'ps-print)
+ :group 'ps-print-zebra)
+
+(defcustom ps-zebra-gray 0.95
+ "*Zebra stripe gray scale.
+See also documentation for `ps-zebra-stripes' and `ps-zebra-stripe-height'."
+ :type 'number
+ :group 'ps-print-zebra)
(defcustom ps-line-number nil
"*Non-nil means print line number."
For example, if you wish to print an EPS image on all pages do:
'((\"~/images/EPS-image.ps\"))"
- :type '(repeat (list file
+ :type '(repeat (list (file :tag "EPS 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
+ (radio (integer :tag "Page")
(cons :tag "Range"
(integer :tag "From")
(integer :tag "To"))))))
- :group 'ps-print)
+ :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
+ :type '(repeat (list (string :tag "Text")
(choice :tag "X" number string (const nil))
(choice :tag "Y" number string (const nil))
(choice :tag "Font" string (const nil))
(choice :tag "Gray" number string (const nil))
(choice :tag "Rotation" number string (const nil))
(repeat :tag "Pages" :inline t
- (radio integer
+ (radio (integer :tag "Page")
(cons :tag "Range"
(integer :tag "From")
(integer :tag "To"))))))
- :group 'ps-print)
+ :group 'ps-print-background)
;;; Horizontal layout
: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."
+(defcustom ps-spool-config '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 :tag "Spool Config"
+ (const lpr-switches) (const setpagedevice)
+ (other :tag "nil" nil))
+ :group 'ps-print-header)
+
+(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."
+ :type 'boolean
+ :group 'ps-print-header)
+
+(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)
:type 'symbol
:group 'ps-print-font)
-(defcustom ps-font-size (if ps-landscape-mode 7 8.5)
+(defcustom ps-font-size '(7 . 8.5)
"*Font size, in points, for ordinary text, when generating PostScript."
- :type 'number
+ :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
:type 'symbol
:group 'ps-print-font)
-(defcustom ps-header-font-size (if ps-landscape-mode 10 12)
+(defcustom ps-header-font-size '(10 . 12)
"*Font size, in points, for text in the header, when generating PostScript."
- :type 'number
+ :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)
+(defcustom ps-header-title-font-size '(12 . 14)
"*Font size, in points, for the top line of text in header, in PostScript."
- :type 'number
+ :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)
: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-header)
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; User commands
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."
(interactive (list (ps-print-preprint current-prefix-arg)))
"Return the current PostScript-generation setup."
(format
"
-\(setq ps-print-color-p %s
- ps-lpr-command %S
- ps-lpr-switches %S
- ps-printer-name %S
+\(setq ps-print-color-p %s
+ ps-lpr-command %S
+ ps-lpr-switches %s
+ ps-printer-name %S
+ ps-print-region-function %s
- ps-paper-type %S
+ ps-paper-type %s
ps-landscape-mode %s
ps-number-of-columns %s
ps-zebra-stripes %s
ps-zebra-stripe-height %s
+ ps-zebra-gray %s
ps-line-number %s
- ps-print-control-characters %S
-
- ps-print-background-image %S
-
- ps-print-background-text %S
-
- ps-print-prologue-header %S
-
- ps-left-margin %s
- ps-right-margin %s
- ps-inter-column %s
- ps-bottom-margin %s
- ps-top-margin %s
- ps-header-offset %s
- ps-header-line-pad %s
- ps-print-header %s
- ps-print-only-one-header %s
- ps-print-header-frame %s
- ps-header-lines %s
- ps-show-n-of-n %s
- ps-spool-duplex %s
-
- ps-multibyte-buffer %S
- ps-font-family %S
+ ps-print-control-characters %s
+
+ ps-print-background-image %s
+
+ ps-print-background-text %s
+
+ ps-print-prologue-header %s
+
+ ps-left-margin %s
+ ps-right-margin %s
+ ps-inter-column %s
+ ps-bottom-margin %s
+ ps-top-margin %s
+ ps-header-offset %s
+ ps-header-line-pad %s
+ ps-print-header %s
+ ps-print-only-one-header %s
+ ps-print-header-frame %s
+ ps-header-lines %s
+ ps-show-n-of-n %s
+ ps-spool-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-lpr-command
(ps-print-quote ps-lpr-switches)
ps-printer-name
+ (ps-print-quote ps-print-region-function)
(ps-print-quote ps-paper-type)
ps-landscape-mode
ps-number-of-columns
ps-zebra-stripes
ps-zebra-stripe-height
+ ps-zebra-gray
ps-line-number
(ps-print-quote ps-print-control-characters)
(ps-print-quote ps-print-background-image)
ps-print-header-frame
ps-header-lines
ps-show-n-of-n
+ (ps-print-quote ps-spool-config)
ps-spool-duplex
- (ps-print-quote ps-multibyte-buffer)
+ 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' and `ps-print-def.el'
(ps-print-quote ps-font-family)
- ps-font-size
+ (ps-print-quote ps-font-size)
(ps-print-quote ps-header-font-family)
- ps-header-font-size
- ps-header-title-font-size))
+ (ps-print-quote ps-header-font-size)
+ (ps-print-quote ps-header-title-font-size)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Utility functions and variables:
(defun ps-print-quote (sym)
- (and sym
- (if (or (symbolp sym) (listp sym))
- (format "'%S" 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
(require 'time-stamp)
-(defvar ps-print-prologue-1
- "% ISOLatin1Encoding stolen from ps_init.ps in GhostScript 2.6.1.4:
+(defconst 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,
% stack: --
/printZebra {
gsave
- 0.985 setgray
+ ZebraGray setgray
/double-zebra ZebraHeight ZebraHeight add def
/yiter double-zebra LineHeight mul neg def
/xiter PrintWidth InterColumn add def
/SpaceWidth /f0 findfont setfont ( ) stringwidth pop def
% ---- save the state of the document (useful for ghostscript!)
/docState save def
- /JackGhostscript where {pop 1 27.7 29.7 div scale}if
% ---- [andrewi] set PageSize based on chosen dimensions
- /setpagedevice where {
- pop
- 1 dict dup
- /PageSize [ PrintPageWidth LeftMargin add RightMargin add
- LandscapePageHeight ] put
- setpagedevice
+ UseSetpagedevice {
+ 0
+ {<< /PageSize [PageWidth LandscapePageHeight] >> setpagedevice}
+ CheckConfig
}{
LandscapeMode {
% ---- translate to bottom-right corner of Portrait page
90 rotate
}if
}ifelse
+ % ---- [jack] Kludge: my ghostscript window is 21x27.7 instead of 21x29.7
+ /JackGhostscript where {pop 1 27.7 29.7 div scale}if
+ % ---- N-Up printing
+ N-Up 1 gt {
+ % ---- landscape
+ N-Up-Landscape {
+ PageWidth 0 translate
+ 90 rotate
+ }if
+ N-Up-Margin dup translate
+ % ---- scale
+ LandscapeMode{
+ /HH PageWidth def
+ /WW LandscapePageHeight def
+ }{
+ /HH LandscapePageHeight def
+ /WW PageWidth def
+ }ifelse
+ WW N-Up-Margin sub N-Up-Margin sub
+ N-Up-Landscape
+ {N-Up-Lines div HH}{N-Up-Columns N-Up-Missing add div WW}ifelse
+ div dup scale
+ 0 N-Up-Repeat 1 sub LandscapePageHeight mul translate
+ % ---- go to start position in page matrix
+ N-Up-XStart N-Up-Missing 0.5 mul
+ LandscapeMode{
+ LandscapePageHeight mul N-Up-YStart add
+ }{
+ PageWidth mul add N-Up-YStart
+ }ifelse
+ translate
+ }if
/ColumnWidth PrintWidth InterColumn add def
% ---- translate to lower left corner of TEXT
LeftMargin BottomMargin translate
/f0 F % this installs Ascent
/PrintStartY PrintHeight Ascent sub def
/ColumnIndex 1 def
-} def
+ /N-Up-Counter N-Up-End 1 sub def
+ SkipFirstPage{save showpage restore}if
+}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
+}def
/BeginDSCPage {
% ---- when 1st column, save the state of the page
- ColumnIndex 1 eq { /pageState save def } if
+ ColumnIndex 1 eq {
+ /pageState save def
+ }if
% ---- save the state of the column
/columnState save def
-} 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
+ 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
+ }if
+ }if
0 PrintStartY moveto % move to where printing will start
PLN
-} def
+}def
/EndPage {
- bg { eolbg } if
-} def
+ 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
+ % ---- N-up printing
+ N-Up 1 gt {
+ N-Up-Counter 0 gt {
+ % ---- Next page on same row
+ /N-Up-Counter N-Up-Counter 1 sub def
+ N-Up-XColumn N-Up-YColumn
+ }{
+ % ---- Next page on next line
+ /N-Up-Counter N-Up-End 1 sub def
+ N-Up-XLine N-Up-YLine
+ }ifelse
+ translate
+ }if
+ }{ % 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
+ }ifelse
+}def
+
+% stack: number-of-pages-per-sheet |- --
+/BeginSheet {
+ /sheetState save def
+ /pages-per-sheet exch def
+ % ---- N-up printing
+ N-Up 1 gt N-Up-Border and pages-per-sheet 0 gt and {
+ % ---- page border
+ gsave
+ 0 setgray
+ LeftMargin neg BottomMargin neg moveto
+ N-Up-Repeat
+ {N-Up-End
+ {gsave
+ PageWidth 0 rlineto
+ 0 LandscapePageHeight rlineto
+ PageWidth neg 0 rlineto
+ closepath stroke
+ grestore
+ /pages-per-sheet pages-per-sheet 1 sub def
+ pages-per-sheet 0 le{exit}if
+ N-Up-XColumn N-Up-YColumn rmoveto
+ }repeat
+ pages-per-sheet 0 le{exit}if
+ N-Up-XLine N-Up-XColumn sub N-Up-YLine rmoveto
+ }repeat
+ grestore
+ }if
+}def
+
+/EndSheet {
+ showpage
+ sheetState restore
+}def
/SetHeaderLines { % nb-lines --
/HeaderLines exch def
% ---- 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
+ % ---- if even page number and duplex, then exchange left and right
+ PageNumber 1 and 0 eq DuplexValue and { exch } if
{ % ---- process the left lines
aload pop
stringwidth pop exch div def
/t1 12 /Helvetica-Oblique DefFont
/t1 F
+ gsave
+ (languagelevel = ) show
+ gs_languagelevel 32 string cvs show
+ grestore
+ 0 FontHeight neg rmoveto
gsave
(For ) show
128 string cvs show
% 3 cm 20 cm moveto 10 /Courier ReportFontInfo showpage
% 3 cm 20 cm moveto ReportAllFontInfo showpage
+/ErrorMessages
+ [(This PostScript printer is not configured with this document page size.)
+ (Duplex printing is not supported on this PostScript printer.)]def
+
+% stack: error-index proc |- --
+/CheckConfig {
+ stopped {
+ 1 cm LandscapePageHeight 0.5 mul moveto
+ /Courier findfont 10 scalefont setfont
+ gsave
+ (ps-print error:) show
+ grestore
+ 0 -10 rmoveto
+ ErrorMessages exch get show
+ showpage
+ $error /newerror false put
+ stop
+ }if
+} bind def
+
")
-(defvar ps-print-prologue-2
+(defconst ps-print-prologue-2
"
% ---- These lines must be kept together because...
")
+(defconst ps-print-duplex-feature
+ "
+% --- duplex feature verification
+1
+UseSetpagedevice {
+ {<< /Duplex DuplexValue /Tumble TumbleValue >> setpagedevice}
+}{
+ {statusdict begin
+ DuplexValue setduplexmode TumbleValue settumble
+ end}
+}ifelse
+CheckConfig
+")
+
;; Start Editing Here:
(defvar ps-source-buffer nil)
(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)
(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
(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)
(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.")
+
+
+(defvar ps-printing-region-p nil
+ "Non-nil means ps-print is printing a region.")
(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))))))
+ (setq ps-printing-region-p region-p
+ ps-printing-region
+ (cons (if region-p
+ (ps-count-lines (point-min) (region-beginning))
+ 1)
+ (ps-count-lines (point-min) (point-max)))))
\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
which long lines wrap around."
(get font-sym 'avg-char-width))
-\f
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; For handling multi-byte characters -- Begin.
-;;
-;; The following comments apply only to this part (through the next ^L).
-;; Author: Kenichi Handa <handa@etl.go.jp>
-;; Maintainer: Kenichi Handa <handa@etl.go.jp>
-
-(eval-and-compile
- (if (not (string< mule-version "4.0"))
- (progn
- (defalias 'ps-mule-next-point '1+)
- (defalias 'ps-mule-chars-in-string 'length)
- (defalias 'ps-mule-string-char 'aref)
- (defsubst ps-mule-next-index (str i) (1+ i)))
- (defun set-buffer-multibyte (arg)
- (setq enable-multibyte-characters arg))
- (defun string-as-unibyte (arg) arg)
- (defun string-as-multibyte (arg) arg)
- (defun charset-after (&optional arg)
- (char-charset (char-after arg)))
- (defun ps-mule-next-point (arg)
- (save-excursion (goto-char arg) (forward-char 1) (point)))
- (defun ps-mule-chars-in-string (string)
- (length string))
- (defalias 'ps-mule-string-char 'aref)
- (defun ps-mule-next-index (str i)
- (1+ i)))
- )
-
-(defvar ps-mule-font-info-database
- nil
- "Alist of charsets with the corresponding font information.
-Each element has the form:
-
- (CHARSET (FONT-TYPE FONT-SRC FONT-NAME ENCODING BYTES) ...)
-
-Where
-
-CHARSET is a charset (symbol) for this font family,
-
-FONT-TYPE is a font type: normal, bold, italic, or bold-italic.
-
-FONT-SRC is a font source: builtin, bdf, vflib, or nil.
-
- If FONT-SRC is builtin, FONT-NAME is a buitin PostScript font name.
-
- If FONT-SRC is bdf, FONT-NAME is a BDF font file name. To use this font,
- the external library `bdf' is required.
-
- If FONT-SRC is vflib, FONT-NAME is the name of a font that VFlib knows.
- To use this font, the external library `vflib' is required.
-
- If FONT-SRC is nil, a proper ASCII font in the variable
- `ps-font-info-database' is used. This is useful for Latin-1 characters.
-
-ENCODING is a coding system to encode a string of characters of CHARSET into a
-proper string matching an encoding of the specified font. ENCODING may be a
-function that does this encoding. In this case, the function is called with
-one argument, the string to encode, and it should return an encoded string.
-
-BYTES specifies how many bytes each character has in the encoded byte
-sequence; it should be 1 or 2.
-
-All multi-byte characters are printed by fonts specified in this database
-regardless of a font family of ASCII characters. The exception is Latin-1
-characters which are printed by the same font as ASCII characters, thus obey
-font family.
-
-See also the variable `ps-font-info-database'.")
-
-(defconst ps-mule-font-info-database-latin
- '((latin-iso8859-1
- (normal nil nil iso-latin-1)))
- "Sample setting of `ps-mule-font-info-database' to use latin fonts.")
-
-(defconst ps-mule-font-info-database-ps
- '((katakana-jisx0201
- (normal builtin "Ryumin-Light.Katakana" ps-mule-encode-7bit 1)
- (bold builtin "GothicBBB-Medium.Katakana" ps-mule-encode-7bit 1)
- (bold-italic builtin "GothicBBB-Medium.Katakana" ps-mule-encode-7bit 1))
- (latin-jisx0201
- (normat builtin "Ryumin-Light.Hankaku" ps-mule-encode-7bit 1)
- (bold builtin "GothicBBB-Medium.Hankaku" ps-mule-encode-7bit 1))
- (japanese-jisx0208
- (normal builtin "Ryumin-Light-H" ps-mule-encode-7bit 2)
- (bold builtin "GothicBBB-Medium-H" ps-mule-encode-7bit 2))
- (korean-ksc5601
- (normal builtin "Batang-Medium-KSC-H" ps-mule-encode-7bit 2)
- (bold builtin " Gulim-Medium-KSC-H" ps-mule-encode-7bit 2))
- )
- "Sample setting of the `ps-mule-font-info-database' to use builtin PS font.
-
-Currently, data for Japanese and Korean PostScript printers are listed.")
-
-(defconst ps-mule-font-info-database-bdf
- '((ascii
- (normal bdf "etl24-latin1.bdf" nil 1)
- (bold bdf "etl16b-latin1.bdf" iso-latin-1 1)
- (italic bdf "etl16i-latin1.bdf" iso-latin-1 1)
- (bold-italic bdf "etl16bi-latin1.bdf" iso-latin-1 1))
- (latin-iso8859-1
- (normal bdf "etl24-latin1.bdf" iso-latin-1 1)
- (bold bdf "etl16b-latin1.bdf" iso-latin-1 1)
- (italic bdf "etl16i-latin1.bdf" iso-latin-1 1)
- (bold-italic bdf "etl16bi-latin1.bdf" iso-latin-1 1))
- (latin-iso8859-2
- (normal bdf "etl24-latin2.bdf" iso-latin-2 1))
- (latin-iso8859-3
- (normal bdf "etl24-latin3.bdf" iso-latin-3 1))
- (latin-iso8859-4
- (normal bdf "etl24-latin4.bdf" iso-latin-4 1))
- (thai-tis620
- (normal bdf "thai-24.bdf" thai-tis620 1))
- (greek-iso8859-7
- (normal bdf "etl24-greek.bdf" greek-iso-8bit 1))
- ;; (arabic-iso8859-6 nil) ; not yet available
- (hebrew-iso8859-8
- (normal bdf "etl24-hebrew.bdf" hebrew-iso-8bit 1))
- (katakana-jisx0201
- (normal bdf "12x24rk.bdf" ps-mule-encode-8bit 1))
- (latin-jisx0201
- (normal bdf "12x24rk.bdf" ps-mule-encode-7bit 1))
- (cyrillic-iso8859-5
- (normal bdf "etl24-cyrillic.bdf" cyrillic-iso-8bit 1))
- (latin-iso8859-9
- (normal bdf "etl24-latin5.bdf" iso-latin-5 1))
- (japanese-jisx0208-1978
- (normal bdf "jiskan24.bdf" ps-mule-encode-7bit 2))
- (chinese-gb2312
- (normal bdf "gb24st.bdf" ps-mule-encode-7bit 2))
- (japanese-jisx0208
- (normal bdf "jiskan24.bdf" ps-mule-encode-7bit 2))
- (korean-ksc5601
- (normal bdf "hanglm24.bdf" ps-mule-encode-7bit 2))
- (japanese-jisx0212
- (normal bdf "jisksp40.bdf" ps-mule-encode-7bit 2))
- (chinese-cns11643-1
- (normal bdf "cns-1-40.bdf" ps-mule-encode-7bit 2))
- (chinese-cns11643-2
- (normal bdf "cns-2-40.bdf" ps-mule-encode-7bit 2))
- (chinese-big5-1
- (normal bdf "taipei24.bdf" chinese-big5 2))
- (chinese-big5-2
- (normal bdf "taipei24.bdf" chinese-big5 2))
- (chinese-sisheng
- (normal bdf "etl24-sisheng.bdf" ps-mule-encode-8bit 1))
- (ipa
- (normal bdf "etl24-ipa.bdf" ps-mule-encode-8bit 1))
- (vietnamese-viscii-lower
- (normal bdf "etl24-viscii.bdf" vietnamese-viscii 1))
- (vietnamese-viscii-upper
- (normal bdf "etl24-viscii.bdf" vietnamese-viscii 1))
- (arabic-digit
- (normal bdf "etl24-arabic0.bdf" ps-mule-encode-7bit 1))
- (arabic-1-column
- (normal bdf "etl24-arabic1.bdf" ps-mule-encode-7bit 1))
- ;; (ascii-right-to-left nil) ; not yet available
- (lao
- (normal bdf "mule-lao-24.bdf" lao 1))
- (arabic-2-column
- (normal bdf "etl24-arabic2.bdf" ps-mule-encode-7bit 1))
- (indian-is13194
- (normal bdf "mule-iscii-24.bdf" ps-mule-encode-7bit 1))
- (indian-1-column
- (normal bdf "mule-indian-1col-24.bdf" ps-mule-encode-7bit 2))
- (tibetan-1-column
- (normal bdf "mule-tibmdx-1col-24.bdf" ps-mule-encode-7bit 2))
- (ethiopic
- (normal bdf "ethiomx24f-uni.bdf" ps-mule-encode-ethiopic 2))
- (chinese-cns11643-3
- (normal bdf "cns-3-40.bdf" ps-mule-encode-7bit 2))
- (chinese-cns11643-4
- (normal bdf "cns-4-40.bdf" ps-mule-encode-7bit 2))
- (chinese-cns11643-5
- (normal bdf "cns-5-40.bdf" ps-mule-encode-7bit 2))
- (chinese-cns11643-6
- (normal bdf "cns-6-40.bdf" ps-mule-encode-7bit 2))
- (chinese-cns11643-7
- (normal bdf "cns-7-40.bdf" ps-mule-encode-7bit 2))
- (indian-2-column
- (normal bdf "mule-indian-24.bdf" ps-mule-encode-7bit 2))
- (tibetan
- (normal bdf "mule-tibmdx-24.bdf" ps-mule-encode-7bit 2)))
- "Sample setting of the `ps-mule-font-info-database' to use BDF fonts.
-BDF (Bitmap Distribution Format) is a format used for distributing X's font
-source file.
-
-Current default value list for BDF fonts is included in `intlfonts-1.1' which is
-a collection of X11 fonts for all characters supported by Emacs.
-
-Using this list as default value to `ps-mule-font-info-database', all characters
-including ASCII and Latin-1 are printed by BDF fonts.
-
-See also `ps-mule-font-info-database-ps-bdf'.")
-
-(defconst ps-mule-font-info-database-ps-bdf
- (cons (car ps-mule-font-info-database-latin)
- (cdr (cdr ps-mule-font-info-database-bdf)))
- "Sample setting of the `ps-mule-font-info-database' to use BDF fonts.
-
-Current default value list for BDF fonts is included in `intlfonts-1.1' which is
-a collection of X11 fonts for all characters supported by Emacs.
-
-Using this list as default value to `ps-mule-font-info-database', all characters
-except ASCII and Latin-1 characters are printed by BDF fonts. ASCII and Latin-1
-characters are printed by PostScript font specified by `ps-font-family' and
-`ps-header-font-family'.
-
-See also `ps-mule-font-info-database-bdf'.")
-
-;; Two typical encoding functions for PostScript fonts.
-
-(defun ps-mule-encode-7bit (string)
- (ps-mule-encode-bit string 0))
-
-(defun ps-mule-encode-8bit (string)
- (ps-mule-encode-bit string 128))
-
-(defun ps-mule-encode-bit (string delta)
- (let* ((dim (charset-dimension (char-charset (ps-mule-string-char string 0))))
- (len (* (ps-mule-chars-in-string string) dim))
- (str (make-string len 0))
- (i 0)
- (j 0))
- (if (= dim 1)
- (while (< j len)
- (aset str j
- (+ (nth 1 (split-char (ps-mule-string-char string i))) delta))
- (setq i (ps-mule-next-index string i)
- j (1+ j)))
- (while (< j len)
- (let ((split (split-char (ps-mule-string-char string i))))
- (aset str j (+ (nth 1 split) delta))
- (aset str (1+ j) (+ (nth 2 split) delta))
- (setq i (ps-mule-next-index string i)
- j (+ j 2)))))
- str))
-
-;; Special encoding function for Ethiopic.
-(define-ccl-program ccl-encode-ethio-unicode
- `(1
- ((read r2)
- (loop
- (if (r2 == ,leading-code-private-22)
- ((read r0)
- (if (r0 == ,(charset-id 'ethiopic))
- ((read r1 r2)
- (r1 &= 127) (r2 &= 127)
- (call ccl-encode-ethio-font)
- (write r1)
- (write-read-repeat r2))
- ((write r2 r0)
- (repeat))))
- (write-read-repeat r2))))))
-
-(defun ps-mule-encode-ethiopic (string)
- (ccl-execute-on-string (symbol-value 'ccl-encode-ethio-unicode)
- (make-vector 9 nil)
- string))
-
-;; A charset which we are now processing.
-(defvar ps-mule-current-charset nil)
-
-(defun ps-mule-get-font-spec (charset font-type)
- "Return FONT-SPEC for printing characters CHARSET with FONT-TYPE.
-FONT-SPEC is a list that has the form:
-
- (FONT-SRC FONT-NAME ENCODING BYTES)
-
-FONT-SPEC is extracted from `ps-mule-font-info-database'.
-
-See the documentation of `ps-mule-font-info-database' for the meaning of each
-element of the list."
- (let ((slot (cdr (assq charset ps-mule-font-info-database))))
- (and slot
- (cdr (or (assq font-type slot)
- (and (eq font-type 'bold-italic)
- (or (assq 'bold slot) (assq 'italic slot)))
- (assq 'normal slot))))))
-
-;; Functions to access each element of FONT-SPEC.
-(defsubst ps-mule-font-spec-src (font-spec) (car font-spec))
-(defsubst ps-mule-font-spec-name (font-spec) (nth 1 font-spec))
-(defsubst ps-mule-font-spec-encoding (font-spec) (nth 2 font-spec))
-(defsubst ps-mule-font-spec-bytes (font-spec) (nth 3 font-spec))
-
-(defsubst ps-mule-printable-p (charset)
- "Non-nil if characters in CHARSET is printable."
- (ps-mule-get-font-spec charset 'normal))
-
-(defconst ps-mule-external-libraries
- '((builtin nil
- nil nil nil)
- (bdf nil
- bdf-generate-prologue bdf-generate-font bdf-generate-glyphs)
- (pcf nil
- pcf-generate-prologue pcf-generate-font pcf-generate-glyphs)
- (vflib nil
- vflib-generate-prologue vflib-generate-font vflib-generate-glyphs))
- "Alist of information of external libraries to support PostScript printing.
-Each element has the form:
-
- (FONT-SRC INITIALIZED-P PROLOGUE-FUNC FONT-FUNC GLYPHS-FUNC)
-
-FONT-SRC is the font source: builtin, bdf, pcf, or vflib. Except for `builtin',
-libraries must have the same name as indicated by FONT-SRC. Currently, we only
-have the `bdf' library.
-
-INITIALIZED-P indicates if this library is initialized or not.
-
-PROLOGUE-FUNC is a function to generate PostScript code which define several
-PostScript procedures that will be called by FONT-FUNC and GLYPHS-FUNC. It is
-called with no argument, and should return a list of strings.
-
-FONT-FUNC is a function to generate PostScript code which define a new font. It
-is called with one argument FONT-SPEC, and should return a list of strings.
-
-GLYPHS-FUNC is a function to generate PostScript code which define glyphs of
-characters. It is called with three arguments FONT-SPEC, CODE-LIST, and BYTES,
-and should return a list of strings.")
-
-(defun ps-mule-init-external-library (font-spec)
- "Initialize external library specified by FONT-SPEC for PostScript printing.
-See the documentation of `ps-mule-get-font-spec' for FONT-SPEC's meaning."
- (let* ((font-src (ps-mule-font-spec-src font-spec))
- (slot (assq font-src ps-mule-external-libraries)))
- (or (not font-src)
- (nth 1 slot)
- (let ((func (nth 2 slot)))
- (if func
- (progn
- (or (featurep font-src) (require font-src))
- (ps-output-prologue (funcall func))))
- (setcar (cdr slot) t)))))
-
-;; Cached glyph information of fonts, alist of:
-;; (FONT-NAME ((FONT-TYPE-NUMBER . SCALED-FONT-NAME) ...)
-;; cache CODE0 CODE1 ...)
-(defvar ps-mule-font-cache nil)
-
-(defun ps-mule-generate-font (font-spec charset)
- "Generate PostScript codes to define a new font in FONT-SPEC for CHARSET."
- (let* ((font-cache (assoc (ps-mule-font-spec-name font-spec)
- ps-mule-font-cache))
- (font-src (ps-mule-font-spec-src font-spec))
- (font-name (ps-mule-font-spec-name font-spec))
- (func (nth 3 (assq font-src ps-mule-external-libraries)))
- (scaled-font-name
- (if (eq charset 'ascii)
- (format "f%d" ps-current-font)
- (format "f%02x-%d"
- (charset-id charset) ps-current-font))))
- (and func (not font-cache)
- (ps-output-prologue (funcall func charset font-spec)))
- (ps-output-prologue
- (list (format "/%s %f /%s Def%sFontMule\n"
- scaled-font-name ps-font-size font-name
- (if (eq ps-mule-current-charset 'ascii) "Ascii" ""))))
- (if font-cache
- (setcar (cdr font-cache)
- (cons (cons ps-current-font scaled-font-name)
- (nth 1 font-cache)))
- (setq font-cache (list font-name
- (list (cons ps-current-font scaled-font-name))
- 'cache)
- ps-mule-font-cache (cons font-cache ps-mule-font-cache)))
- font-cache))
-
-(defun ps-mule-generate-glyphs (font-spec code-list)
- "Generate PostScript codes which generate glyphs for CODE-LIST of FONT-SPEC."
- (let* ((font-src (ps-mule-font-spec-src font-spec))
- (func (nth 4 (assq font-src ps-mule-external-libraries))))
- (and func
- (ps-output-prologue
- (funcall func font-spec code-list
- (ps-mule-font-spec-bytes font-spec))))))
-
-(defvar ps-last-font nil)
-
-(defun ps-mule-prepare-font (font-spec string charset &optional no-setfont)
- "Generate PostScript codes to print STRING of CHARSET by font FONT-SPEC.
-
-The generated code is inserted on prologue part except the code that sets the
-current font (using PostScript procedure `FM').
-
-If optional arg NO-SETFONT is non-nil, don't generate the code for setting the
-current font."
- (let ((font-cache (assoc (ps-mule-font-spec-name font-spec)
- ps-mule-font-cache)))
- (or (and font-cache (assq ps-current-font (nth 1 font-cache)))
- (setq font-cache (ps-mule-generate-font font-spec charset)))
- (or no-setfont
- (let ((new-font (cdr (assq ps-current-font (nth 1 font-cache)))))
- (or (equal new-font ps-last-font)
- (progn
- (ps-output (format "/%s FM\n" new-font))
- (setq ps-last-font new-font)))))
- (if (nth 4 (assq (ps-mule-font-spec-src font-spec)
- ps-mule-external-libraries))
- ;; We have to generate PostScript codes which define glyphs.
- (let* ((cached-codes (nthcdr 2 font-cache))
- (newcodes nil)
- (bytes (ps-mule-font-spec-bytes font-spec))
- (len (length string))
- (i 0)
- code)
- (while (< i len)
- (setq code (if (= bytes 1)
- (aref string i)
- (+ (* (aref string i) 256) (aref string (1+ i)))))
- (or (memq code cached-codes)
- (progn
- (setq newcodes (cons code newcodes))
- (setcdr cached-codes (cons code (cdr cached-codes)))))
- (setq i (+ i bytes)))
- (and newcodes
- (ps-mule-generate-glyphs font-spec newcodes))))))
-
-;; List of charsets of multi-byte characters in a text being printed.
-;; If the text doesn't contain any multi-byte characters (i.e. only
-;; ASCII), the value is nil.
-(defvar ps-mule-charset-list nil)
-
-(defvar ps-mule-prologue-generated nil)
-
-;; This is a PostScript code inserted in the header of generated PostScript.
-(defconst ps-mule-prologue
- "%%%% Start of Mule Section
-
-%% Working dictionary for general use.
-/MuleDict 10 dict def
-
-%% Define already scaled font for non-ASCII character sets.
-/DefFontMule { % fontname size basefont |- --
- findfont exch scalefont definefont pop
-} bind def
-
-%% Define already scaled font for ASCII character sets.
-/DefAsciiFontMule { % fontname size basefont |-
- MuleDict begin
- findfont dup /Encoding get /ISOLatin1Encoding exch def
- exch scalefont reencodeFontISO
- end
-} def
-
-%% Set the specified non-ASCII font to use. It doesn't install
-%% Ascent, etc.
-/FM { % fontname |- --
- findfont setfont
-} bind def
-
-%% Show vacant box for characters which don't have appropriate font.
-/SB { % count column |- --
- SpaceWidth mul /w exch def
- 1 exch 1 exch { %for
- pop
- gsave
- 0 setlinewidth
- 0 Descent rmoveto w 0 rlineto
- 0 LineHeight rlineto w neg 0 rlineto closepath stroke
- grestore
- w 0 rmoveto
- } for
-} bind def
-
-%% Flag to tell if we are now handling a composite character. This is
-%% defined here because both composite character handler and bitmap font
-%% handler require it.
-/Cmpchar false def
-
-%%%% End of Mule Section
-
-"
- "PostScript code for printing multi-byte characters.")
-
-(defun ps-mule-skip-same-charset (charset)
- "Skip characters of CHARSET following the current point."
- (while (eq (charset-after) charset)
- (forward-char 1)))
-
-(defun ps-mule-find-wrappoint (from to char-width)
- "Find the longest sequence which is printable in the current line.
-
-The search starts at FROM and goes until TO. It is assumed that all characters
-between FROM and TO belong to a charset in `ps-mule-current-charset'.
-
-CHAR-WIDTH is the average width of ASCII characters in the current font.
-
-Returns the value:
-
- (ENDPOS . RUN-WIDTH)
-
-Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
-the sequence."
- (let (run-width)
- (if (eq ps-mule-current-charset 'composition)
- ;; We must draw one char by one.
- (let ((ch (char-after from)))
- (setq run-width (* (char-width ch) char-width))
- (if (> run-width ps-width-remaining)
- (setq run-width ps-width-remaining)
- (setq from (ps-mule-next-point from))))
- ;; We assume that all characters in this range have the same width.
- (let ((width (charset-width ps-mule-current-charset)))
- (setq run-width (* (- to from) char-width width))
- (if (> run-width ps-width-remaining)
- (setq from (min
- (+ from (truncate (/ ps-width-remaining char-width)))
- to)
- run-width ps-width-remaining)
- (setq from to))))
- (cons from run-width)))
-
-(defun ps-mule-plot-string (from to &optional bg-color)
- "Generate PostScript code for ploting characters in the region FROM and TO.
-
-It is assumed that all characters in this region belong to a charset in
-`ps-mule-current-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."
- (let* ((wrappoint (ps-mule-find-wrappoint
- from to (ps-avg-char-width 'ps-font-for-text)))
- (to (car wrappoint))
- (font-type (car (nth ps-current-font
- (ps-font-alist 'ps-font-for-text))))
- (font-spec (ps-mule-get-font-spec ps-mule-current-charset font-type))
- (string (buffer-substring-no-properties from to)))
- (cond
- ((= from to)
- ;; We can't print any more characters in the current line.
- nil)
-
- (font-spec
- ;; We surely have a font for printing this character set.
- (ps-output-string (ps-mule-string-encoding font-spec string))
- (ps-output " S\n"))
-
- ((eq ps-mule-current-charset 'latin-iso8859-1)
- ;; Latin-1 can be printed by a normal ASCII font.
- (ps-output-string (ps-mule-string-ascii string))
- (ps-output " S\n"))
-
- ((eq ps-mule-current-charset 'composition)
- (let* ((ch (char-after from))
- (width (char-width ch))
- (ch-list (decompose-composite-char ch 'list t)))
- (if (consp (nth 1 ch-list))
- (ps-mule-plot-rule-cmpchar ch-list width font-type)
- (ps-mule-plot-cmpchar ch-list width t font-type))))
-
- (t
- ;; No way to print this charset. Just show a vacant box of an
- ;; appropriate width.
- (ps-output (format "%d %d SB\n"
- (length string)
- (if (eq ps-mule-current-charset 'composition)
- (char-width (char-after from))
- (charset-width ps-mule-current-charset))))))
- wrappoint))
-
-;; Composite font support
-
-(defvar ps-mule-cmpchar-prologue-generated nil)
-
-(defconst ps-mule-cmpchar-prologue
- "%%%% Composite character handler
-/CmpcharWidth 0 def
-/CmpcharRelativeCompose 0 def
-/CmpcharRelativeSkip 0.4 def
-
-%% Get a bounding box (relative to currentpoint) of STR.
-/GetPathBox { % str |- --
- gsave
- currentfont /FontType get 3 eq { %ifelse
- stringwidth pop pop
- } {
- currentpoint /y exch def pop
- false charpath flattenpath pathbbox
- y sub /URY exch def pop
- y sub /LLY exch def pop
- } ifelse
- grestore
-} bind def
-
-%% Beginning of composite char.
-/BC { % str xoff width |- --
- /Cmpchar true def
- /CmpcharWidth exch def
- currentfont /RelativeCompose known {
- /CmpcharRelativeCompose currentfont /RelativeCompose get def
- } {
- /CmpcharRelativeCompose false def
- } ifelse
- /bgsave bg def /bgcolorsave bgcolor def
- /Effectsave Effect def
- gsave % Reflect effect only at first
- /Effect Effect 1 2 add 4 add 16 add and def
- /f0 findfont setfont ( ) 0 CmpcharWidth getinterval S
- grestore
- /Effect Effectsave 8 32 add and def % enable only shadow and outline
- false BG
- gsave SpaceWidth mul 0 rmoveto dup GetPathBox S grestore
- /y currentpoint exch pop def
- /HIGH URY y add def /LOW LLY y add def
-} bind def
-
-%% End of composite char.
-/EC { % -- |- --
- /bg bgsave def /bgcolor bgcolorsave def
- /Effect Effectsave def
- /Cmpchar false def
- CmpcharWidth SpaceWidth mul 0 rmoveto
-} bind def
-
-%% Rule base composition
-/RBC { % str xoff gref nref |- --
- /nref exch def /gref exch def
- gsave
- SpaceWidth mul 0 rmoveto
- dup
- GetPathBox
- [ HIGH currentpoint exch pop LOW HIGH LOW add 2 div ] gref get
- [ URY LLY sub LLY neg 0 URY LLY sub 2 div ] nref get
- sub /btm exch def
- /top btm URY LLY sub add def
- top HIGH gt { /HIGH top def } if
- btm LOW lt { /LOW btm def } if
- currentpoint pop btm LLY sub moveto
- S
- grestore
-} bind def
-
-%% Relative composition
-/RLC { % str |- --
- gsave
- dup GetPathBox
- CmpcharRelativeCompose type /integertype eq {
- LLY CmpcharRelativeCompose gt { % compose on top
- currentpoint pop HIGH LLY sub CmpcharRelativeSkip add moveto
- /HIGH HIGH URY LLY sub add CmpcharRelativeSkip add def
- } { URY 0 le { % compose under bottom
- currentpoint pop LOW LLY add CmpcharRelativeSkip sub moveto
- /LOW LOW URY LLY sub sub CmpcharRelativeSkip sub def
- } if } ifelse } if
- S
- grestore
-} bind def
-%%%% End of composite character handler
-
-"
- "PostScript code for printing composite characters.")
-
-(defun ps-mule-plot-rule-cmpchar (ch-rule-list total-width font-type)
- (let* ((leftmost 0.0)
- (rightmost (float (char-width (car ch-rule-list))))
- (the-list (cons '(3 . 3) ch-rule-list))
- (cmpchar-elements nil))
- (while the-list
- (let* ((this (car the-list))
- (gref (car this))
- (nref (cdr this))
- ;; X-axis info (0:left, 1:center, 2:right)
- (gref-x (% gref 3))
- (nref-x (% nref 3))
- ;; Y-axis info (0:top, 1:base, 2:bottom, 3:center)
- (gref-y (if (= gref 4) 3 (/ gref 3)))
- (nref-y (if (= nref 4) 3 (/ nref 3)))
- (width (float (char-width (car (cdr the-list)))))
- left)
- (setq left (+ leftmost
- (/ (* (- rightmost leftmost) gref-x) 2.0)
- (- (/ (* nref-x width) 2.0)))
- cmpchar-elements (cons (list (car (cdr the-list))
- left gref-y nref-y)
- cmpchar-elements)
- leftmost (min left leftmost)
- rightmost (max (+ left width) rightmost)
- the-list (nthcdr 2 the-list))))
- (if (< leftmost 0)
- (let ((the-list cmpchar-elements))
- (while the-list
- (setcar (cdr (car the-list))
- (- (nth 1 (car the-list)) leftmost))
- (setq the-list (cdr the-list)))))
- (ps-mule-plot-cmpchar (nreverse cmpchar-elements)
- total-width nil font-type)))
-
-(defun ps-mule-plot-cmpchar (elements total-width relativep font-type)
- (let* ((elt (car elements))
- (ch (if relativep elt (car elt))))
- (ps-output-string (ps-mule-prepare-cmpchar-font ch font-type))
- (ps-output (format " %d %d BC "
- (if relativep 0 (nth 1 elt))
- total-width))
- (while (setq elements (cdr elements))
- (setq elt (car elements)
- ch (if relativep elt (car elt)))
- (ps-output-string (ps-mule-prepare-cmpchar-font ch font-type))
- (ps-output (if relativep
- " RLC "
- (format " %d %d %d RBC "
- (nth 1 elt) (nth 2 elt) (nth 3 elt))))))
- (ps-output "EC\n"))
-
-(defun ps-mule-prepare-cmpchar-font (char font-type)
- (let* ((ps-mule-current-charset (char-charset char))
- (font-spec (ps-mule-get-font-spec ps-mule-current-charset font-type)))
- (cond (font-spec
- (ps-mule-string-encoding font-spec (char-to-string char)))
-
- ((eq ps-mule-current-charset 'latin-iso8859-1)
- (ps-mule-string-ascii (char-to-string char)))
-
- (t
- ;; No font for CHAR.
- (ps-set-font ps-current-font)
- " "))))
-
-(defun ps-mule-string-ascii (str)
- (ps-set-font ps-current-font)
- (string-as-unibyte (encode-coding-string str 'iso-latin-1)))
-
-(defun ps-mule-string-encoding (font-spec str)
- (let ((encoding (ps-mule-font-spec-encoding font-spec)))
- (cond ((coding-system-p encoding)
- (setq str (encode-coding-string str encoding)))
- ((functionp encoding)
- (setq str (funcall encoding str)))
- (encoding
- (error "Invalid coding system or function: %s" encoding)))
- (setq str (string-as-unibyte str))
- (if (ps-mule-font-spec-src font-spec)
- (ps-mule-prepare-font font-spec str ps-mule-current-charset)
- (ps-set-font ps-current-font))
- str))
-
-;; Bitmap font support
-
-(defvar ps-mule-bitmap-prologue-generated nil)
-
-(defconst ps-mule-bitmap-prologue
- "%%%% Bitmap font handler
-
-/str7 7 string def % working area
-
-%% We grow the dictionary one bunch (1024 entries) by one.
-/BitmapDictArray 256 array def
-/BitmapDictLength 1024 def
-/BitmapDictIndex -1 def
-
-/NewBitmapDict { % -- |- --
- /BitmapDictIndex BitmapDictIndex 1 add def
- BitmapDictArray BitmapDictIndex BitmapDictLength dict put
-} bind def
-
-%% Make at least one dictionary.
-NewBitmapDict
-
-/AddBitmap { % gloval-charname bitmap-data |- --
- BitmapDictArray BitmapDictIndex get
- dup length BitmapDictLength ge {
- pop
- NewBitmapDict
- BitmapDictArray BitmapDictIndex get
- } if
- 3 1 roll put
-} bind def
-
-/GetBitmap { % gloval-charname |- bitmap-data
- 0 1 BitmapDictIndex { BitmapDictArray exch get begin } for
- load
- 0 1 BitmapDictIndex { pop end } for
-} bind def
-
-%% Return a global character name which can be used as a key in the
-%% bitmap dictionary.
-/GlobalCharName { % fontidx code1 code2 |- gloval-charname
- exch 256 mul add exch 65536 mul add 16777216 add 16 str7 cvrs 0 66 put
- str7 cvn
-} bind def
-
-%% Character code holder for a 2-byte character.
-/FirstCode -1 def
-
-%% Glyph rendering procedure
-/BuildGlyphCommon { % fontdict charname |- --
- 1 index /FontDimension get 1 eq { /FirstCode 0 store } if
- NameIndexDict exch get % STACK: fontdict charcode
- FirstCode 0 lt { %ifelse
- %% This is the first byte of a 2-byte character. Just
- %% remember it for the moment.
- /FirstCode exch store
- pop
- 0 0 setcharwidth
- } {
- 1 index /FontSize get /size exch def
- 1 index /FontSpaceWidthRatio get /ratio exch def
- 1 index /FontIndex get exch FirstCode exch
- GlobalCharName GetBitmap /bmp exch def
- %% bmp == [ DWIDTH BBX-WIDTH BBX-HEIGHT BBX-XOFF BBX-YOFF BITMAP ]
- Cmpchar { %ifelse
- /FontMatrix get [ exch { size div } forall ] /mtrx exch def
- bmp 3 get bmp 4 get mtrx transform
- /LLY exch def pop
- bmp 1 get bmp 3 get add bmp 2 get bmp 4 get add mtrx transform
- /URY exch def pop
- } {
- pop
- } ifelse
- /FirstCode -1 store
-
- bmp 0 get SpaceWidthRatio ratio div mul size div 0 % wx wy
- setcharwidth % We can't use setcachedevice here.
-
- bmp 1 get 0 gt bmp 2 get 0 gt and {
- bmp 1 get bmp 2 get % width height
- true % polarity
- [ size 0 0 size neg bmp 3 get neg bmp 2 get bmp 4 get add ] % matrix
- bmp 5 1 getinterval cvx % datasrc
- imagemask
- } if
- } ifelse
-} bind def
-
-/BuildCharCommon {
- 1 index /Encoding get exch get
- 1 index /BuildGlyph get exec
-} bind def
-
-%% Bitmap font creater
-
-%% Common Encoding shared by all bitmap fonts.
-/EncodingCommon 256 array def
-%% Mapping table from character name to character code.
-/NameIndexDict 256 dict def
-0 1 255 { %for
- /idx exch def
- /idxname idx 256 add 16 (XXX) cvrs dup 0 67 put cvn def % `C' == 67
- EncodingCommon idx idxname put
- NameIndexDict idxname idx put
-} for
-
-/GlobalFontIndex 0 def
-
-%% fontname dim col fontsize relative-compose baseline-offset fbbx |- --
-/BitmapFont {
- 15 dict begin
- /FontBBox exch def
- /BaselineOffset exch def
- /RelativeCompose exch def
- /FontSize exch def
- /FontBBox [ FontBBox { FontSize div } forall ] def
- FontBBox 2 get FontBBox 0 get sub exch div
- /FontSpaceWidthRatio exch def
- /FontDimension exch def
- /FontIndex GlobalFontIndex def
- /FontType 3 def
- /FontMatrix matrix def
- /Encoding EncodingCommon def
- /BuildGlyph { BuildGlyphCommon } def
- /BuildChar { BuildCharCommon } def
- currentdict end
- definefont pop
- /GlobalFontIndex GlobalFontIndex 1 add def
-} bind def
-
-%% Define a new bitmap font.
-%% fontname dim col fontsize relative-compose baseline-offset fbbx |- --
-/NF {
- /fbbx exch def
- %% Convert BDF's FontBoundingBox to PostScript's FontBBox
- [ fbbx 2 get fbbx 3 get
- fbbx 2 get fbbx 0 get add fbbx 3 get fbbx 1 get add ]
- BitmapFont
-} bind def
-
-%% Define a glyph for the specified font and character.
-/NG { % fontname charcode bitmap-data |- --
- /bmp exch def
- exch findfont dup /BaselineOffset get bmp 4 get add bmp exch 4 exch put
- /FontIndex get exch
- dup 256 idiv exch 256 mod GlobalCharName
- bmp AddBitmap
-} bind def
-%%%% End of bitmap font handler
-
-")
-
-;; External library support.
-
-;; The following three functions are to be called from external
-;; libraries which support bitmap fonts (e.g. `bdf') to get
-;; appropriate PostScript code.
-
-(defun ps-mule-generate-bitmap-prologue ()
- (unless ps-mule-bitmap-prologue-generated
- (setq ps-mule-bitmap-prologue-generated t)
- (list ps-mule-bitmap-prologue)))
-
-(defun ps-mule-generate-bitmap-font (&rest args)
- (list (apply 'format "/%s %d %d %f %S %d %S NF\n" args)))
-
-(defun ps-mule-generate-bitmap-glyph (font-name code dwidth bbx bitmap)
- (format "/%s %d [ %d %d %d %d %d <%s> ] NG\n"
- font-name code
- dwidth (aref bbx 0) (aref bbx 1) (aref bbx 2) (aref bbx 3)
- bitmap))
-
-;; Mule specific initializers.
-
-(defun ps-mule-initialize ()
- "Produce Poscript code in the prologue part for multi-byte characters."
- (setq ps-mule-font-info-database
- (cond ((eq ps-multibyte-buffer 'non-latin-printer)
- ps-mule-font-info-database-ps)
- ((eq ps-multibyte-buffer 'bdf-font)
- ps-mule-font-info-database-bdf)
- ((eq ps-multibyte-buffer 'bdf-font-except-latin)
- ps-mule-font-info-database-ps-bdf)
- (t
- ps-mule-font-info-database-latin))
- ps-mule-current-charset 'ascii
- ps-mule-font-cache nil
- ps-mule-prologue-generated nil
- ps-mule-cmpchar-prologue-generated nil
- ps-mule-bitmap-prologue-generated nil)
- (mapcar `(lambda (x) (setcar (cdr x) nil))
- ps-mule-external-libraries))
-
-(defun ps-mule-begin (from to)
- (and (boundp 'enable-multibyte-characters)
- enable-multibyte-characters
- ;; Initialize `ps-mule-charset-list'. If some characters aren't
- ;; printable, warn it.
- (let ((charsets (delete 'ascii (find-charset-region from to))))
- (setq ps-mule-charset-list charsets)
- (save-excursion
- (goto-char from)
- (and (search-forward "\200" to t)
- (setq ps-mule-charset-list
- (cons 'composition ps-mule-charset-list))))
- (while charsets
- (cond
- ((or (eq (car charsets) 'composition)
- (ps-mule-printable-p (car charsets)))
- (setq charsets (cdr charsets)))
- ((y-or-n-p "Font for some characters not found, continue anyway? ")
- (setq charsets nil))
- (t
- (error "Printing cancelled"))))))
-
- (if ps-mule-charset-list
- (let ((the-list ps-mule-charset-list)
- font-spec)
- (unless ps-mule-prologue-generated
- (ps-output-prologue ps-mule-prologue)
- (setq ps-mule-prologue-generated t))
- ;; If external functions are necessary, generate prologues for them.
- (while the-list
- (cond ((and (eq (car the-list) 'composition)
- (not ps-mule-cmpchar-prologue-generated))
- (ps-output-prologue ps-mule-cmpchar-prologue)
- (setq ps-mule-cmpchar-prologue-generated t))
- ((setq font-spec (ps-mule-get-font-spec (car the-list) 'normal))
- (ps-mule-init-external-library font-spec)))
- (setq the-list (cdr the-list)))))
-
- ;; If ASCII font is also specified in ps-mule-font-info-database,
- ;; use it istead of what specified in ps-font-info-database.
- (let ((font-spec (ps-mule-get-font-spec 'ascii 'normal)))
- (if font-spec
- (progn
- (unless ps-mule-prologue-generated
- (ps-output-prologue ps-mule-prologue)
- (setq ps-mule-prologue-generated t))
- (ps-mule-init-external-library font-spec)
- (let ((font (ps-font-alist 'ps-font-for-text))
- (i 0))
- (while font
- (let ((ps-current-font i))
- ;; Be sure to download a glyph for SPACE in advance.
- (ps-mule-prepare-font
- (ps-mule-get-font-spec 'ascii (car font))
- " " 'ascii 'no-setfont))
- (setq font (cdr font)
- i (1+ i))))))))
-
-;; For handling multi-byte characters -- End.
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-\f
-
(defun ps-line-lengths-internal ()
"Display the correspondence between a line length and a font size,
using the current ps-print setup.
Try: pr -t file | awk '{printf \"%3d %s\n\", length($0), $0}' | sort -r | head"
(let ((buf (get-buffer-create "*Line-lengths*"))
- (ifs ps-font-size) ; 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))
(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-output-boolean (name bool &optional no-def)
+ (ps-output (format "/%s %s%s"
+ name (if bool "true" "false") (if no-def "\n" " def\n"))))
(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) "BottomMargin") ; 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))))
+ (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))))))
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"))))
(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)
+ (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)
+ (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)
+ (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))
+
+
(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-printing 1) (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%%DocumentNeededResources: font Times-Roman Times-Italic\n%%+ font "
- (mapconcat 'identity
- (ps-remove-duplicates
- (append (ps-fonts 'ps-font-for-text)
- (list (ps-font 'ps-font-for-header 'normal)
- (ps-font 'ps-font-for-header 'bold))))
- "\n%%+ font ")
- "\n%%Pages: (atend)\n%%Requirements:"
- (if ps-spool-duplex " duplex\n" "\n"))
-
- (let ((comments (if (functionp ps-print-prologue-header)
- (funcall ps-print-prologue-header)
- ps-print-prologue-header)))
- (and (stringp comments)
- (ps-output comments)))
-
- (ps-output "%%EndComments\n\n%%BeginPrologue\n\n")
-
- (ps-output-boolean "LandscapeMode" ps-landscape-mode)
- (ps-output (format "/NumberOfColumns %d def\n" ps-number-of-columns)
-
- (format "/LandscapePageHeight %s def\n" ps-landscape-page-height)
- (format "/PrintPageWidth %s def\n"
- (- (* (+ ps-print-width ps-inter-column)
- ps-number-of-columns)
- ps-inter-column))
- (format "/PrintWidth %s def\n" ps-print-width)
- (format "/PrintHeight %s def\n" ps-print-height)
-
- (format "/LeftMargin %s def\n" ps-left-margin)
- (format "/RightMargin %s def\n" ps-right-margin) ; 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) cvn DefFont\n" ; /h0 14 /Helvetica-Bold DefFont
- ps-header-title-font-size (ps-font 'ps-font-for-header
- 'bold))
- (format "/h1 %s (%s) cvn 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) cvn DefFont\n"
- i
- ps-font-size
- (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-mule-initialize)
-
- (ps-output "%%EndPrologue\n%%BeginSetup\nBeginDoc\n%%EndSetup\n\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
+ (format " duplex%s" (if tumble "(tumble)\n" "\n"))
+ "\n"))
+
+ (let ((comments (if (functionp ps-print-prologue-header)
+ (funcall ps-print-prologue-header)
+ ps-print-prologue-header)))
+ (and (stringp comments)
+ (ps-output comments)))
+
+ (ps-output "%%EndComments\n\n%%BeginPrologue\n\n"
+ "/gs_languagelevel /languagelevel where {pop languagelevel}{1}ifelse def\n\n")
+
+ (ps-output-boolean "SkipFirstPage " ps-banner-page-when-duplexing)
+ (ps-output-boolean "LandscapeMode "
+ (or ps-landscape-mode
+ (eq (ps-n-up-landscape n-up) 'pag)))
+ (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 "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 "Zebra " ps-zebra-stripes)
+ (ps-output-boolean "PrintLineNumber " ps-line-number)
+ (ps-output (format "/ZebraHeight %d def\n" ps-zebra-stripe-height)
+ (format "/ZebraGray %s def\n" ps-zebra-gray)
+ "/UseSetpagedevice "
+ (if (eq ps-spool-config 'setpagedevice)
+ "/setpagedevice where {pop true}{false}ifelse def\n"
+ "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" ps-n-up-margin)
+ " def\n/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 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) 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 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) 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)
+ ps-print-duplex-feature
+ "%%EndFeature\n")))
+ (ps-output "\n/Lines 0 def\n/PageCount 0 def\n\nBeginDoc\n%%EndSetup\n"))
+
+
+(defun ps-boolean-capitalized (bool)
+ (if bool "True" "False"))
+
(defun ps-header-dirpart ()
(let ((fname (buffer-file-name)))
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 ()
(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
- (if ps-mule-charset-list
- (cond ((eq ps-print-control-characters '8-bit)
- "[^\040-\176]")
- ((eq ps-print-control-characters 'control-8-bit)
- (string-as-multibyte "[^\040-\176\240-\377]"))
- ((eq ps-print-control-characters 'control)
- (string-as-multibyte "[^\040-\176\200-\377]"))
- (t (string-as-multibyte "[^\000-\011\013\015-\377")))
- (cond ((eq ps-print-control-characters '8-bit)
- (string-as-unibyte "[\000-\037\177-\377]"))
- ((eq ps-print-control-characters 'control-8-bit)
- (string-as-unibyte "[\000-\037\177-\237]"))
- ((eq ps-print-control-characters 'control)
- "[\000-\037\177]")
- (t "[\t\n\f]")))))
+ (cond ((eq ps-print-control-characters '8-bit)
+ (string-as-unibyte "[\000-\037\177-\377]"))
+ ((eq ps-print-control-characters 'control-8-bit)
+ (string-as-unibyte "[\000-\037\177-\237]"))
+ ((eq ps-print-control-characters 'control)
+ "[\000-\037\177]")
+ (t "[\t\n\f]"))))
(defmacro ps-page-number ()
`(1+ (/ (1- ps-page-count) ps-number-of-columns)))
(defun ps-end-file ()
- (ps-output "\n%%Trailer\n%%Pages: "
- (format "%d" ps-page-postscript)
+ ;; 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" 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 (format "\n%%%%Page: %d %d\n"
+ ps-page-postscript ps-page-order))
+ (ps-output (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)
(setq ps-width-remaining ps-print-width
- ps-height-remaining ps-print-height
- ps-mule-current-charset 'ascii)
+ ps-height-remaining ps-print-height)
(ps-header-page)
(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))
(let* ((wrappoint (ps-find-wrappoint from to
(ps-avg-char-width 'ps-font-for-text)))
(to (car wrappoint))
- (string (buffer-substring-no-properties from to))
- (font-spec
- (ps-mule-get-font-spec
- 'ascii
- (car (nth ps-current-font (ps-font-alist 'ps-font-for-text))))))
- (and font-spec
- (ps-mule-prepare-font font-spec string 'ascii))
+ (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)
(setq ps-last-font (format "f%d" (setq ps-current-font font)))
(ps-output (format "/%s F\n" ps-last-font)))
(ps-output (number-to-string effects) " EF\n")
(setq ps-current-effect effects)))
- (setq ps-mule-current-charset 'ascii)
-
;; Starting at the beginning of the specified region...
(save-excursion
(goto-char from)
(let* ((match-point (match-beginning 0))
(match (char-after match-point)))
(when (< from match-point)
- (unless (eq ps-mule-current-charset 'ascii)
- (ps-set-font ps-current-font)
- (setq ps-mule-current-charset 'ascii))
+ (ps-mule-set-ascii-font)
(ps-plot 'ps-basic-plot-string from match-point bg-color))
(cond
((= match ?\t) ; tab
(forward-char -1)
(setq from (+ linestart (current-column)))
(when (re-search-forward "[ \t]+" to t)
- (unless (eq ps-mule-current-charset 'ascii)
- (ps-set-font ps-current-font)
- (setq ps-mule-current-charset 'ascii))
+ (ps-mule-set-ascii-font)
(ps-plot 'ps-basic-plot-whitespace
from (+ linestart (current-column))
bg-color))))
((> match 255) ; a multi-byte character
(let ((charset (char-charset match)))
(or (eq charset 'composition)
- (ps-mule-skip-same-charset charset))
- (setq ps-mule-current-charset charset)
+ (while (eq (charset-after) charset)
+ (forward-char 1)))
(ps-plot 'ps-mule-plot-string match-point (point) bg-color)))
; characters from ^@ to ^_ and
(t ; characters from 127 to 255
(ps-control-character match)))
(setq from (point)))
;; region without control characters nor multi-byte characters
- (when (not (eq ps-mule-current-charset 'ascii))
- (ps-set-font ps-current-font)
- (setq ps-mule-current-charset 'ascii))
+ (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")))
(if (color-specifier-p x-color)
(color-name x-color)
x-color)))))
- (t (error "No available function to determine X color values."))))
+ (t
+ (error "No available function to determine X color values."))))
))
(goto-char to))
+(defun ps-xemacs-face-kind-p (face kind kind-regex kind-list)
+ (let* ((frame-font (or (face-font-instance face)
+ (face-font-instance 'default)))
+ (kind-cons (and frame-font
+ (assq kind
+ (font-instance-properties frame-font))))
+ (kind-spec (cdr-safe kind-cons))
+ (case-fold-search t))
+ (or (and kind-spec (string-match kind-regex kind-spec))
+ ;; Kludge-compatible:
+ (memq face kind-list))))
+
+
(cond ((eq ps-print-emacs-type 'emacs) ; emacs
(defun ps-face-bold-p (face)
; xemacs
; lucid
(t ; epoch
- (defun ps-xemacs-face-kind-p (face kind kind-regex kind-list)
- (let* ((frame-font (or (face-font-instance face)
- (face-font-instance 'default)))
- (kind-cons (and frame-font
- (assq kind
- (font-instance-properties frame-font))))
- (kind-spec (cdr-safe kind-cons))
- (case-fold-search t))
- (or (and kind-spec (string-match kind-regex kind-spec))
- ;; Kludge-compatible:
- (memq face kind-list))))
-
(defun ps-face-bold-p (face)
(ps-xemacs-face-kind-p face 'WEIGHT_NAME "bold\\|demibold"
ps-bold-faces))
(setq needs-begin-file t))
(save-excursion
(set-buffer ps-source-buffer)
- (and needs-begin-file (ps-begin-file))
- (ps-mule-begin from to)
(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-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 ()
+ (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))))
+
+
;; 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 ps-printer-name)))
- (let ((printer (or (and (boundp 'dos-ps-printer)
- (stringp (symbol-value 'dos-ps-printer))
- (symbol-value 'dos-ps-printer))
- ps-printer-name))
- ;; It seems that we must be careful about the
- ;; directory name that gets added by write-region
- ;; when using the standard "PRN" or "LPTx" ports.
- ;; The call can fail if the directory is on a
- ;; network drive.
- (safe-dir (or (getenv "windir") (getenv "TMPDIR") "c:/")))
- (write-region (point-min) (point-max)
- (expand-file-name printer safe-dir) 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 "-P" ps-printer-name)))
+ ps-lpr-switches)))
+ (apply (or ps-print-region-function 'call-process-region)
+ (point-min) (point-max) ps-lpr-command nil
+ (and (fboundp 'start-process) 0)
+ nil
+ (ps-flatten-list ; dynamic evaluation
+ (mapcar 'ps-eval-switch ps-lpr-switches)))))
(and ps-razzle-dazzle (message "Printing...done")))
(kill-buffer ps-spool-buffer)))
(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))
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