mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-05 08:53:45 +00:00
6685 lines
218 KiB
EmacsLisp
6685 lines
218 KiB
EmacsLisp
;;; printing.el --- printing utilities
|
|
|
|
;; Copyright (C) 2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
|
|
|
|
;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
|
|
;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
|
|
;; Time-stamp: <2005-09-18 05:57:14 deego>
|
|
;; Keywords: wp, print, PostScript
|
|
;; Version: 6.8.4
|
|
;; X-URL: http://www.cpqd.com.br/~vinicius/emacs/
|
|
|
|
(defconst pr-version "6.8.4"
|
|
"printing.el, v 6.8.4 <2005/06/11 vinicius>
|
|
|
|
Please send all bug fixes and enhancements to
|
|
Vinicius Jose Latorre <viniciusjl@ig.com.br>
|
|
")
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;; GNU Emacs is free software; you can redistribute it and/or modify it under
|
|
;; the terms of the GNU General Public License as published by the Free
|
|
;; Software Foundation; either version 2, or (at your option) any later
|
|
;; version.
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
;; WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
;; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
;; details.
|
|
|
|
;; You should have received a copy of the GNU General Public License along with
|
|
;; GNU Emacs; see the file COPYING. If not, write to the Free Software
|
|
;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
;;; Commentary:
|
|
|
|
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;; Introduction
|
|
;; ------------
|
|
;;
|
|
;; With `printing' you can preview or print a PostScript file. You can also
|
|
;; print a text file using PostScript, and preview or print buffers that use
|
|
;; certain special modes like mh-folder-mode, rmail-summary-mode,
|
|
;; gnus-summary-mode, etc. This package also includes a PostScript/text
|
|
;; printer database.
|
|
;;
|
|
;; There are two user interfaces:
|
|
;;
|
|
;; * Menu interface:
|
|
;; The `printing' menu replaces the usual print options in the menu bar.
|
|
;; This is the default user interface.
|
|
;;
|
|
;; * Buffer interface:
|
|
;; You can use a buffer interface instead of menus. It looks like a
|
|
;; customization buffer. Basically, it has the same options found in the
|
|
;; menu and some extra options, all this on a buffer.
|
|
;;
|
|
;; `printing' is prepared to run on GNU, Unix and NT systems.
|
|
;; On GNU or Unix system, `printing' depends on gs and gv utilities.
|
|
;; On NT system, `printing' depends on gstools (gswin32.exe and gsview32.exe).
|
|
;; To obtain ghostscript, ghostview and GSview see the URL
|
|
;; `http://www.gnu.org/software/ghostscript/ghostscript.html'.
|
|
;;
|
|
;; `printing' depends on ps-print package to generate PostScript files, to
|
|
;; spool and to despool PostScript buffer. So, `printing' provides an
|
|
;; interface to ps-print package and it also provides some extra stuff.
|
|
;;
|
|
;; To download the latest ps-print package see
|
|
;; `http://www.cpqd.com.br/~vinicius/emacs/ps-print.tar.gz'.
|
|
;; Please, see README file for ps-print installation instructions.
|
|
;;
|
|
;; `printing' was inspired on:
|
|
;;
|
|
;; print-nt.el Frederic Corne <frederic.corne@erli.fr>
|
|
;; Special printing functions for Windows NT
|
|
;;
|
|
;; mh-e-init.el Tom Vogels <tov@ece.cmu.edu>
|
|
;; PS-print for mail messages
|
|
;;
|
|
;; win32-ps-print.el Matthew O. Persico <mpersico@erols.com>
|
|
;; PostScript printing with ghostscript
|
|
;;
|
|
;; ps-print-interface.el Volker Franz <volker.franz@tuebingen.mpg.de>
|
|
;; Graphical front end for ps-print and previewing
|
|
;;
|
|
;;
|
|
;; Log Messages
|
|
;; ------------
|
|
;;
|
|
;; The buffer *Printing Command Output* is where the `printing' log messages
|
|
;; are inserted. All program called by `printing' has a log entry in the
|
|
;; buffer *Printing Command Output*. A log entry has the following form:
|
|
;;
|
|
;; PROGRAM (ARG...)
|
|
;; MESSAGE
|
|
;; Exit status: CODE
|
|
;;
|
|
;; Where
|
|
;; PROGRAM is the program activated by `printing',
|
|
;; ARG is an argument passed to PROGRAM (it can have more than one argument),
|
|
;; MESSAGE is an error message returned by PROGRAM (it can have no message, if
|
|
;; PROGRAM is successful),
|
|
;; and CODE is a numeric exit status or a signal description string.
|
|
;;
|
|
;; For example, after previewing a PostScript file, *Printing Command Output*
|
|
;; will have the following entry:
|
|
;;
|
|
;; /usr/X11R6/bin/gv ("/home/user/example/file.ps")
|
|
;; Exit status: 0
|
|
;;
|
|
;; In the example above, the previewing was successful. If during previewing,
|
|
;; you quit gv execution (by typing C-g during Emacs session), the log entry
|
|
;; would be:
|
|
;;
|
|
;; /usr/X11R6/bin/gv ("/home/user/example/file.ps")
|
|
;; Exit status: Quit
|
|
;;
|
|
;; So, if something goes wrong, a good place to take a look is the buffer
|
|
;; *Printing Command Output*. Don't forget to see also the buffer *Messages*,
|
|
;; it can help.
|
|
;;
|
|
;;
|
|
;; Novices (First Users)
|
|
;; ---------------------
|
|
;;
|
|
;; First of all, see printing documentation only to get an idea of what
|
|
;; `printing' is capable.
|
|
;;
|
|
;; Then try to set the variables: `pr-ps-name', `pr-ps-printer-alist',
|
|
;; `pr-txt-name', `pr-txt-printer-alist' and `pr-path-alist'. These variables
|
|
;; are the main variables for printing processing.
|
|
;;
|
|
;; Now, please, see these variables documentation deeper. You can do this by
|
|
;; typing C-h v pr-ps-name RET (for example) if you already loaded printing
|
|
;; package, or by browsing printing.el source file.
|
|
;;
|
|
;; If the documentation isn't clear or if you find a way to improve the
|
|
;; documentation, please, send an email to maintainer. All printing users
|
|
;; will thank you.
|
|
;;
|
|
;; One way to set variables is by calling `pr-customize', customize all
|
|
;; variables and save the customization by future sessions (see Options
|
|
;; section). Other way is by coding your settings on Emacs init file (that is,
|
|
;; ~/.emacs file), see below for a first setting template that it should be
|
|
;; inserted on your ~/.emacs file (or c:/_emacs, if you're using Windows 9x/NT
|
|
;; or MS-DOS):
|
|
;;
|
|
;; * Example of setting for Windows system:
|
|
;;
|
|
;; (require 'printing) ; load printing package
|
|
;; (setq pr-path-alist
|
|
;; '((windows "c:/applications/executables" PATH ghostview mpage)
|
|
;; (ghostview "c:/gs/gsview-dir")
|
|
;; (mpage "c:/mpage-dir")
|
|
;; ))
|
|
;; (setq pr-txt-name 'prt_06a)
|
|
;; (setq pr-txt-printer-alist
|
|
;; '((prt_06a "print" nil "/D:\\\\printers\\prt_06a")
|
|
;; (prt_07c nil nil "/D:\\\\printers\\prt_07c")
|
|
;; (PRN "" nil "PRN")
|
|
;; (standard "redpr.exe" nil "")
|
|
;; ))
|
|
;; (setq pr-ps-name 'lps_06b)
|
|
;; (setq pr-ps-printer-alist
|
|
;; '((lps_06a "print" nil "/D:" "\\\\printers\\lps_06a")
|
|
;; (lps_06b "print" nil nil "\\\\printers\\lps_06b")
|
|
;; (lps_07c "print" nil "" "/D:\\\\printers\\lps_07c")
|
|
;; (lps_08c nil nil nil "\\\\printers\\lps_08c")
|
|
;; (LPT1 "" nil "" "LPT1:")
|
|
;; (PRN "" nil "" "PRN")
|
|
;; (standard "redpr.exe" nil "" "")
|
|
;; ))
|
|
;; (pr-update-menus t) ; update now printer and utility menus
|
|
;;
|
|
;; * Example of setting for GNU or Unix system:
|
|
;;
|
|
;; (require 'printing) ; load printing package
|
|
;; (setq pr-path-alist
|
|
;; '((unix "." "~/bin" ghostview mpage PATH)
|
|
;; (ghostview "$HOME/bin/gsview-dir")
|
|
;; (mpage "$HOME/bin/mpage-dir")
|
|
;; ))
|
|
;; (setq pr-txt-name 'prt_06a)
|
|
;; (setq pr-txt-printer-alist
|
|
;; '((prt_06a "lpr" nil "prt_06a")
|
|
;; (prt_07c nil nil "prt_07c")
|
|
;; ))
|
|
;; (setq pr-ps-name 'lps_06b)
|
|
;; (setq pr-ps-printer-alist
|
|
;; '((lps_06b "lpr" nil "-P" "lps_06b")
|
|
;; (lps_07c "lpr" nil nil "lps_07c")
|
|
;; (lps_08c nil nil nil "lps_08c")
|
|
;; ))
|
|
;; (pr-update-menus t) ; update now printer and utility menus
|
|
;;
|
|
;;
|
|
;; NOTE 1: Don't forget to download and install ghostscript utilities (see
|
|
;; Utilities section).
|
|
;;
|
|
;; NOTE 2: The `printer-name' and `ps-printer-name' variables don't need to be
|
|
;; set, as they are implicit set by `pr-ps-printer-alist' and
|
|
;; `pr-txt-printer-alist'.
|
|
;;
|
|
;; NOTE 3: The duplex feature will only work on PostScript printers that
|
|
;; support this feature.
|
|
;; You can check if your PostScript printer supports duplex feature
|
|
;; by checking the printer manual. Or you can try these steps:
|
|
;; 1. Open a buffer (or use the *scratch* buffer).
|
|
;; 2. Type:
|
|
;; First line (on first page)
|
|
;; ^L
|
|
;; Second line (on second page)
|
|
;; 3. Print this buffer with duplex turned on.
|
|
;; If it's printed 2 (two) sheets of paper, then your PostScript
|
|
;; printer doesn't have duplex feature; otherwise, it's ok, your
|
|
;; printer does have duplex feature.
|
|
;;
|
|
;; NOTE 4: See Tips section.
|
|
;;
|
|
;;
|
|
;; Tips
|
|
;; ----
|
|
;;
|
|
;; 1. If you have a local printer, that is, a printer which is connected
|
|
;; directly to your computer, don't forget to connect the printer to your
|
|
;; computer before printing.
|
|
;;
|
|
;; 2. If you try to print a file and it seems that the file was printed, but
|
|
;; there is no paper in the printer, then try to set `pr-delete-temp-file'
|
|
;; to nil. Probably `printing' is deleting the temporary file before your
|
|
;; local system can get it to send to the printer.
|
|
;;
|
|
;; 3. Don't try to print a dynamic buffer, that is, a buffer which is
|
|
;; modifying while `printing' tries to print. Eventually you got an error
|
|
;; message. Instead, save the dynamic buffer to a file or copy it in
|
|
;; another buffer and, then, print the file or the new static buffer.
|
|
;; An example of dynamic buffer is the *Messages* buffer.
|
|
;;
|
|
;; 4. When running Emacs on Windows (with or without cygwin), check if your
|
|
;; printer is a text printer or not by typing in a DOS window:
|
|
;;
|
|
;; print /D:\\host\printer somefile.txt
|
|
;;
|
|
;; Where, `host' is the machine where the printer is directly connected,
|
|
;; `printer' is the printer name and `somefile.txt' is a text file.
|
|
;;
|
|
;; If the printer `\\host\printer' doesn't print the content of
|
|
;; `somefile.txt' or, instead, it returns the following message:
|
|
;;
|
|
;; PostScript Error Handler
|
|
;; Offending Command = CCC
|
|
;; Stack =
|
|
;;
|
|
;; Where `CCC' is whatever is at the beginning of the text to be printed.
|
|
;;
|
|
;; Therefore, the printer `\\host\printer' is not a text printer, but a
|
|
;; PostScript printer. So, please, don't include this printer in
|
|
;; `pr-txt-printer-alist' (which see).
|
|
;;
|
|
;; 5. You can use gsprint instead of ghostscript to print monochrome PostScript
|
|
;; files in Windows. The gsprint utility documentation says that it is more
|
|
;; efficient than ghostscript to print monochrome PostScript.
|
|
;;
|
|
;; To print non-monochrome PostScript file, the efficiency of ghostscript
|
|
;; is similar to gsprint.
|
|
;;
|
|
;; Also the gsprint utility comes together with gsview distribution.
|
|
;;
|
|
;; For more information about gsprint see
|
|
;; `http://www.cs.wisc.edu/~ghost/gsview/gsprint.htm'.
|
|
;;
|
|
;; As an example of gsprint declaration:
|
|
;;
|
|
;; (setq pr-ps-printer-alist
|
|
;; '((A "gsprint" ("-all" "-twoup") "-printer " "my-b/w-printer-name")
|
|
;; (B "gsprint" ("-all" "-twoup") nil "-printer my-b/w-printer-name")
|
|
;; ;; some other printer declaration
|
|
;; ))
|
|
;;
|
|
;; The example above declares that printer A prints all pages (-all) and two
|
|
;; pages per sheet (-twoup). The printer B declaration does the same as the
|
|
;; printer A declaration, the only difference is the printer name selection.
|
|
;;
|
|
;; There are other command line options like:
|
|
;;
|
|
;; -mono Render in monochrome as 1bit/pixel (only black and white).
|
|
;; -grey Render in greyscale as 8bits/pixel.
|
|
;; -color Render in color as 24bits/pixel.
|
|
;;
|
|
;; The default is `-mono'. So, printer A and B in the example above are
|
|
;; using implicitly the `-mono' option. Note that in `-mono' no gray tone
|
|
;; or color is printed, this includes the zebra stripes, that is, in `-mono'
|
|
;; the zebra stripes are not printed.
|
|
;;
|
|
;; See also documentation for `pr-ps-printer-alist'.
|
|
;;
|
|
;;
|
|
;; Using `printing'
|
|
;; ----------------
|
|
;;
|
|
;; To use `printing' insert in your ~/.emacs file (or c:/_emacs, if you're
|
|
;; using Windows 9x/NT or MS-DOS):
|
|
;;
|
|
;; (require 'printing)
|
|
;; ;; ...some user settings...
|
|
;; (pr-update-menus t)
|
|
;;
|
|
;; During `pr-update-menus' evaluation:
|
|
;; * On Emacs 20:
|
|
;; it replaces the Tools/Print menu by Tools/Printing menu.
|
|
;; * On Emacs 21:
|
|
;; it replaces the File/Print* menu entries by File/Print menu.
|
|
;; Please, see section Menu Layout below for menu explanation.
|
|
;;
|
|
;; To use `printing' utilities you can use the Printing menu options, type M-x
|
|
;; followed by one of the commands below, or type a key associated with the
|
|
;; command you want (if there is a key binding).
|
|
;;
|
|
;; `printing' has the following commands:
|
|
;;
|
|
;; pr-interface
|
|
;; pr-ps-directory-preview
|
|
;; pr-ps-directory-using-ghostscript
|
|
;; pr-ps-directory-print
|
|
;; pr-ps-directory-ps-print
|
|
;; pr-ps-buffer-preview
|
|
;; pr-ps-buffer-using-ghostscript
|
|
;; pr-ps-buffer-print
|
|
;; pr-ps-buffer-ps-print
|
|
;; pr-ps-region-preview
|
|
;; pr-ps-region-using-ghostscript
|
|
;; pr-ps-region-print
|
|
;; pr-ps-region-ps-print
|
|
;; pr-ps-mode-preview
|
|
;; pr-ps-mode-using-ghostscript
|
|
;; pr-ps-mode-print
|
|
;; pr-ps-mode-ps-print
|
|
;; pr-ps-file-preview
|
|
;; pr-ps-file-up-preview
|
|
;; pr-ps-file-using-ghostscript
|
|
;; pr-ps-file-print
|
|
;; pr-ps-file-ps-print
|
|
;; pr-ps-file-up-ps-print
|
|
;; pr-ps-fast-fire
|
|
;; pr-despool-preview
|
|
;; pr-despool-using-ghostscript
|
|
;; pr-despool-print
|
|
;; pr-despool-ps-print
|
|
;; pr-printify-directory
|
|
;; pr-printify-buffer
|
|
;; pr-printify-region
|
|
;; pr-txt-directory
|
|
;; pr-txt-buffer
|
|
;; pr-txt-region
|
|
;; pr-txt-mode
|
|
;; pr-txt-fast-fire
|
|
;; pr-toggle-file-duplex
|
|
;; pr-toggle-file-tumble
|
|
;; pr-toggle-file-landscape
|
|
;; pr-toggle-ghostscript
|
|
;; pr-toggle-faces
|
|
;; pr-toggle-spool
|
|
;; pr-toggle-duplex
|
|
;; pr-toggle-tumble
|
|
;; pr-toggle-landscape
|
|
;; pr-toggle-upside-down
|
|
;; pr-toggle-line
|
|
;; pr-toggle-zebra
|
|
;; pr-toggle-header
|
|
;; pr-toggle-lock
|
|
;; pr-toggle-region
|
|
;; pr-toggle-mode
|
|
;; pr-customize
|
|
;; lpr-customize
|
|
;; pr-help
|
|
;; pr-ps-name
|
|
;; pr-txt-name
|
|
;; pr-ps-utility
|
|
;; pr-show-ps-setup
|
|
;; pr-show-pr-setup
|
|
;; pr-show-lpr-setup
|
|
;;
|
|
;; The general meanings of above commands are:
|
|
;;
|
|
;; PREFIX:
|
|
;; `pr-interface' buffer interface for printing package.
|
|
;; `pr-help' help for printing package.
|
|
;; `pr-ps-name' interactively select a PostScript printer.
|
|
;; `pr-txt-name' interactively select a text printer.
|
|
;; `pr-ps-utility' interactively select a PostScript utility.
|
|
;; `pr-show-*-setup' show current settings.
|
|
;; `pr-ps-*' deal with PostScript code generation.
|
|
;; `pr-txt-*' deal with text generation.
|
|
;; `pr-toggle-*' toggle on/off some boolean variable.
|
|
;; `pr-despool-*' despool the PostScript spooling buffer.
|
|
;; `pr-printify-*' replace nonprintable ASCII by printable ASCII
|
|
;; representation.
|
|
;;
|
|
;; SUFFIX:
|
|
;; `*-customize' customization.
|
|
;; `*-preview' preview a PostScript file.
|
|
;; `*-using-ghostscript' use ghostscript to print.
|
|
;; `*-fast-fire' fast fire command (see it for documentation).
|
|
;; `*-print' send PostScript directly to printer.
|
|
;; `*-ps-print' send PostScript directly to printer or use
|
|
;; ghostscript to print. It depends on
|
|
;; `pr-print-using-ghostscript' option.
|
|
;;
|
|
;; INFIX/SUFFIX:
|
|
;; `*-directory*' process a directory.
|
|
;; `*-buffer*' process a buffer.
|
|
;; `*-region*' process a region.
|
|
;; `*-mode*' process a major mode (see explanation below).
|
|
;; `*-file-*' process a PostScript file.
|
|
;; `*-file-up-*' process a PostScript file using a filter utility.
|
|
;;
|
|
;; Here are some examples:
|
|
;;
|
|
;; `pr-ps-buffer-using-ghostscript'
|
|
;; Use ghostscript to print a buffer.
|
|
;;
|
|
;; `pr-ps-file-print'
|
|
;; Print a PostScript file.
|
|
;;
|
|
;; `pr-toggle-spool'
|
|
;; Toggle spooling buffer.
|
|
;;
|
|
;; So you can preview through ghostview, use ghostscript to print (if you don't
|
|
;; have a PostScript printer) or send directly to printer a PostScript code
|
|
;; generated by `ps-print' package.
|
|
;;
|
|
;; Besides operating one buffer or region each time, you also can postpone
|
|
;; previewing or printing by saving the PostScript code generated in a
|
|
;; temporary Emacs buffer. This way you can save banner pages between
|
|
;; successive printing. You can toggle on/off spooling by invoking
|
|
;; `pr-toggle-spool' interactively or through menu bar.
|
|
;;
|
|
;; If you type, for example:
|
|
;;
|
|
;; C-u M-x pr-ps-buffer-print RET
|
|
;;
|
|
;; The `pr-ps-buffer-print' command prompts you for a n-up printing number and
|
|
;; a file name, and save the PostScript code generated to the file name instead
|
|
;; of sending to printer.
|
|
;;
|
|
;; This behavior is similar with the commands that deal with PostScript code
|
|
;; generation, that is, with `pr-ps-*' and `pr-despool-*' commands. If
|
|
;; spooling is on, only `pr-despool-*' commands prompt for a file name and save
|
|
;; the PostScript code spooled in this file.
|
|
;;
|
|
;; Besides the behavior described above, the `*-directory*' commands also
|
|
;; prompt for a directory and a file name regexp. So, it's possible to process
|
|
;; all or certain files on a directory at once (see also documentation for
|
|
;; `pr-list-directory').
|
|
;;
|
|
;; `printing' has also a special way to handle some major mode through
|
|
;; `*-mode*' commands. So it's possible to customize a major mode printing,
|
|
;; it's only needed to declare the customization in `pr-mode-alist' (see
|
|
;; section Options) and invoke some of `*-mode*' commands. An example for
|
|
;; major mode usage is when you're using gnus (or mh, or rmail, etc.) and
|
|
;; you're in the *Summary* buffer, if you forget to switch to the *Article*
|
|
;; buffer before printing, you'll get a nicely formatted list of article
|
|
;; subjects shows up at the printer. With major mode printing you don't need
|
|
;; to switch from gnus *Summary* buffer first.
|
|
;;
|
|
;; Current global keyboard mapping for GNU Emacs is:
|
|
;;
|
|
;; (global-set-key [print] 'pr-ps-fast-fire)
|
|
;; (global-set-key [M-print] 'pr-ps-mode-using-ghostscript)
|
|
;; (global-set-key [S-print] 'pr-ps-mode-using-ghostscript)
|
|
;; (global-set-key [C-print] 'pr-txt-fast-fire)
|
|
;; (global-set-key [C-M-print] 'pr-txt-fast-fire)
|
|
;;
|
|
;; And for XEmacs is:
|
|
;;
|
|
;; (global-set-key 'f22 'pr-ps-fast-fire)
|
|
;; (global-set-key '(meta f22) 'pr-ps-mode-using-ghostscript)
|
|
;; (global-set-key '(shift f22) 'pr-ps-mode-using-ghostscript)
|
|
;; (global-set-key '(control f22) 'pr-txt-fast-fire)
|
|
;; (global-set-key '(control meta f22) 'pr-txt-fast-fire)
|
|
;;
|
|
;; As a suggestion of global keyboard mapping for some `printing' commands:
|
|
;;
|
|
;; (global-set-key "\C-ci" 'pr-interface)
|
|
;; (global-set-key "\C-cbp" 'pr-ps-buffer-print)
|
|
;; (global-set-key "\C-cbx" 'pr-ps-buffer-preview)
|
|
;; (global-set-key "\C-cbb" 'pr-ps-buffer-using-ghostscript)
|
|
;; (global-set-key "\C-crp" 'pr-ps-region-print)
|
|
;; (global-set-key "\C-crx" 'pr-ps-region-preview)
|
|
;; (global-set-key "\C-crr" 'pr-ps-region-using-ghostscript)
|
|
;;
|
|
;;
|
|
;; Options
|
|
;; -------
|
|
;;
|
|
;; Below it's shown a brief description of `printing' options, please, see the
|
|
;; options declaration in the code for a long documentation.
|
|
;;
|
|
;; `pr-path-style' Specify which path style to use for external
|
|
;; commands.
|
|
;;
|
|
;; `pr-path-alist' Specify an alist for command paths.
|
|
;;
|
|
;; `pr-txt-name' Specify a printer for printing a text file.
|
|
;;
|
|
;; `pr-txt-printer-alist' Specify an alist of all text printers.
|
|
;;
|
|
;; `pr-ps-name' Specify a printer for printing a PostScript
|
|
;; file.
|
|
;;
|
|
;; `pr-ps-printer-alist' Specify an alist for all PostScript printers.
|
|
;;
|
|
;; `pr-temp-dir' Specify a directory for temporary files during
|
|
;; printing.
|
|
;;
|
|
;; `pr-ps-temp-file' Specify PostScript temporary file name prefix.
|
|
;;
|
|
;; `pr-file-modes' Specify the file permission bits for newly
|
|
;; created files.
|
|
;;
|
|
;; `pr-gv-command' Specify path and name of the gsview/gv
|
|
;; utility.
|
|
;;
|
|
;; `pr-gs-command' Specify path and name of the ghostscript
|
|
;; utility.
|
|
;;
|
|
;; `pr-gs-switches' Specify ghostscript switches.
|
|
;;
|
|
;; `pr-gs-device' Specify ghostscript device switch value.
|
|
;;
|
|
;; `pr-gs-resolution' Specify ghostscript resolution switch value.
|
|
;;
|
|
;; `pr-print-using-ghostscript' Non-nil means print using ghostscript.
|
|
;;
|
|
;; `pr-faces-p' Non-nil means print with face attributes.
|
|
;;
|
|
;; `pr-spool-p' Non-nil means spool printing in a buffer.
|
|
;;
|
|
;; `pr-file-landscape' Non-nil means print PostScript file in
|
|
;; landscape orientation.
|
|
;;
|
|
;; `pr-file-duplex' Non-nil means print PostScript file in duplex
|
|
;; mode.
|
|
;;
|
|
;; `pr-file-tumble' Non-nil means print PostScript file in tumble
|
|
;; mode.
|
|
;;
|
|
;; `pr-auto-region' Non-nil means region is automagically detected.
|
|
;;
|
|
;; `pr-auto-mode' Non-nil means major-mode specific printing is
|
|
;; prefered over normal printing.
|
|
;;
|
|
;; `pr-mode-alist' Specify an alist for a major-mode and printing
|
|
;; function.
|
|
;;
|
|
;; `pr-ps-utility' Specify PostScript utility processing.
|
|
;;
|
|
;; `pr-ps-utility-alist' Specify an alist for PostScript utility
|
|
;; processing.
|
|
;;
|
|
;; `pr-menu-lock' Non-nil means menu is locked while selecting
|
|
;; toggle options.
|
|
;;
|
|
;; `pr-menu-char-height' Specify menu char height in pixels.
|
|
;;
|
|
;; `pr-menu-char-width' Specify menu char width in pixels.
|
|
;;
|
|
;; `pr-setting-database' Specify an alist for settings in general.
|
|
;;
|
|
;; `pr-visible-entry-list' Specify a list of Printing menu visible
|
|
;; entries.
|
|
;;
|
|
;; `pr-delete-temp-file' Non-nil means delete temporary files.
|
|
;;
|
|
;; `pr-list-directory' Non-nil means list directory when processing a
|
|
;; directory.
|
|
;;
|
|
;; `pr-buffer-name' Specify the name of the buffer interface for
|
|
;; printing package.
|
|
;;
|
|
;; `pr-buffer-name-ignore' Specify a regexp list for buffer names to be
|
|
;; ignored in interface buffer.
|
|
;;
|
|
;; `pr-buffer-verbose' Non-nil means to be verbose when editing a
|
|
;; field in interface buffer.
|
|
;;
|
|
;; To set the above options you may:
|
|
;;
|
|
;; a) insert the code in your ~/.emacs, like:
|
|
;;
|
|
;; (setq pr-faces-p t)
|
|
;;
|
|
;; This way always keep your default settings when you enter a new Emacs
|
|
;; session.
|
|
;;
|
|
;; b) or use `set-variable' in your Emacs session, like:
|
|
;;
|
|
;; M-x set-variable RET pr-faces-p RET t RET
|
|
;;
|
|
;; This way keep your settings only during the current Emacs session.
|
|
;;
|
|
;; c) or use customization, for example:
|
|
;; click on menu-bar *Help* option,
|
|
;; then click on *Customize*,
|
|
;; then click on *Browse Customization Groups*,
|
|
;; expand *PostScript* group,
|
|
;; expand *Printing* group
|
|
;; and then customize `printing' options.
|
|
;; Through this way, you may choose if the settings are kept or not when
|
|
;; you leave out the current Emacs session.
|
|
;;
|
|
;; d) or see the option value:
|
|
;;
|
|
;; C-h v pr-faces-p RET
|
|
;;
|
|
;; and click the *customize* hypertext button.
|
|
;; Through this way, you may choose if the settings are kept or not when
|
|
;; you leave out the current Emacs session.
|
|
;;
|
|
;; e) or invoke:
|
|
;;
|
|
;; M-x pr-customize RET
|
|
;;
|
|
;; and then customize `printing' options.
|
|
;; Through this way, you may choose if the settings are kept or not when
|
|
;; you leave out the current Emacs session.
|
|
;;
|
|
;; f) or use menu bar, for example:
|
|
;; click on menu-bar *File* option,
|
|
;; then click on *Printing*,
|
|
;; then click on *Customize*,
|
|
;; then click on *printing*
|
|
;; and then customize `printing' options.
|
|
;; Through this way, you may choose if the settings are kept or not when
|
|
;; you leave out the current Emacs session.
|
|
;;
|
|
;;
|
|
;; Menu Layout
|
|
;; -----------
|
|
;;
|
|
;; The `printing' menu (Tools/Printing or File/Print) has the following layout:
|
|
;;
|
|
;; +-----------------------------+
|
|
;; A 0 | Printing Interface |
|
|
;; +-----------------------------+ +-A---------+ +-B------+
|
|
;; I 1 | PostScript Preview >|-------|Directory >|-----|1-up |
|
|
;; 2 | PostScript Print >|---- A |Buffer >|-- B |2-up |
|
|
;; 3 | PostScript Printer: name >|---- C |Region >|-- B |4-up |
|
|
;; +-----------------------------+ |Mode >|-- B |Other...|
|
|
;; II 4 | Printify >|-----\ |File >|--\ +--------+
|
|
;; 5 | Print >|---\ | |Despool... | |
|
|
;; 6 | Text Printer: name >|-\ | | +-----------+ |
|
|
;; +-----------------------------+ | | | +---------+ +------------+
|
|
;; III 7 |[ ]Landscape | | | \-|Directory| | No Prep... | Ia
|
|
;; 8 |[ ]Print Header | | | |Buffer | +------------+ Ib
|
|
;; 9 |[ ]Print Header Frame | | | |Region | | name >|- C
|
|
;; 10 |[ ]Line Number | | | +---------+ +------------+
|
|
;; 11 |[ ]Zebra Stripes | | | +---------+ | 1-up... | Ic
|
|
;; 12 |[ ]Duplex | | \---|Directory| | 2-up... |
|
|
;; 13 |[ ]Tumble | \--\ |Buffer | | 4-up... |
|
|
;; 14 |[ ]Upside-Down | | |Region | | Other... |
|
|
;; 15 | Print All Pages >|--\ | |Mode | +------------+
|
|
;; +-----------------------------+ | | +---------+ |[ ]Landscape| Id
|
|
;; IV 16 |[ ]Spool Buffer | | | +-C-------+ |[ ]Duplex | Ie
|
|
;; 17 |[ ]Print with faces | | \--|( )name A| |[ ]Tumble | If
|
|
;; 18 |[ ]Print via Ghostscript | | |( )name B| +------------+
|
|
;; +-----------------------------+ | |... |
|
|
;; V 19 |[ ]Auto Region | | |(*)name |
|
|
;; 20 |[ ]Auto Mode | | |... |
|
|
;; 21 |[ ]Menu Lock | | +---------+ +--------------+
|
|
;; +-----------------------------+ \------------------|(*)All Pages |
|
|
;; VI 22 | Customize >|--- D +-D------+ |( )Even Pages |
|
|
;; 23 | Show Settings >|-------|printing| |( )Odd Pages |
|
|
;; 24 | Help | |ps-print| |( )Even Sheets|
|
|
;; +-----------------------------+ |lpr | |( )Odd Sheets |
|
|
;; +--------+ +--------------+
|
|
;;
|
|
;; See `pr-visible-entry-list' for hiding some parts of the menu.
|
|
;;
|
|
;; The menu has the following sections:
|
|
;;
|
|
;; A. Interface:
|
|
;;
|
|
;; 0. You can use a buffer interface instead of menus. It looks like the
|
|
;; customization buffer. Basically, it has the same options found in the
|
|
;; menu and some extra options, all this on a buffer.
|
|
;;
|
|
;; I. PostScript printing:
|
|
;;
|
|
;; 1. You can generate a PostScript file (if you type C-u before activating
|
|
;; menu) or PostScript temporary file for a directory, a buffer, a region
|
|
;; or a major mode, choosing 1-up, 2-up, 4-up or any other n-up printing;
|
|
;; after file generation, ghostview is activated using the file generated
|
|
;; as argument. This option is disabled if spooling is on (option 16).
|
|
;; Also, if you already have a PostScript file you can preview it.
|
|
;; Instead of previewing each buffer, region or major mode at once, you
|
|
;; can save temporarily the PostScript code generated in a buffer and
|
|
;; preview it later. The option `Despool...' despools the PostScript
|
|
;; spooling buffer in a temporary file and uses ghostview to preview it.
|
|
;; If you type C-u before choosing this option, the PostScript code
|
|
;; generated is saved in a file instead of saving in a temporary file.
|
|
;; To spool the PostScript code generated you need to turn on the option
|
|
;; 16. The option `Despool...' is enabled if spooling is on (option
|
|
;; 16).
|
|
;;
|
|
;; NOTE 1: It's possible to customize a major mode printing, just declare
|
|
;; the customization in `pr-mode-alist' and invoke some of
|
|
;; `*-mode*' commands or select Mode option in Printing menu. An
|
|
;; example for major mode usage is when you're using gnus (or mh,
|
|
;; or rmail, etc.) and you're in the *Summary* buffer, if you
|
|
;; forget to switch to the *Article* buffer before printing,
|
|
;; you'll get a nicely formatted list of article subjects shows
|
|
;; up at the printer. With major mode printing you don't need to
|
|
;; switch from gnus *Summary* buffer first.
|
|
;;
|
|
;; NOTE 2: There are the following options for PostScript file
|
|
;; processing:
|
|
;; Ia. Print the file *No Preprocessing*, that is, send it
|
|
;; directly to PostScript printer.
|
|
;; Ib. PostScript utility processing selection.
|
|
;; See `pr-ps-utility-alist' and `pr-setting-database' for
|
|
;; documentation.
|
|
;; Ic. Do n-up processing before printing.
|
|
;; Id. Toggle on/off landscape for PostScript file processing.
|
|
;; Ie. Toggle on/off duplex for PostScript file processing.
|
|
;; If. Toggle on/off tumble for PostScript file processing.
|
|
;;
|
|
;; NOTE 3: Don't forget to download and install the utilities declared on
|
|
;; `pr-ps-utility-alist'.
|
|
;;
|
|
;; 2. Operate the same way as option 1, but it sends directly the PostScript
|
|
;; code (or put in a file, if you've typed C-u) or it uses ghostscript to
|
|
;; print the PostScript file generated. It depends on option 18, if it's
|
|
;; turned on, it uses ghostscript; otherwise, it sends directly to
|
|
;; printer. If spooling is on (option 16), the PostScript code is saved
|
|
;; temporarily in a buffer instead of printing it or saving it in a file.
|
|
;; Also, if you already have a PostScript file you can print it. Instead
|
|
;; of printing each buffer, region or major mode at once, you can save
|
|
;; temporarily the PostScript code generated in a buffer and print it
|
|
;; later. The option `Despool...' despools the PostScript spooling
|
|
;; buffer directly on a printer. If you type C-u before choosing this
|
|
;; option, the PostScript code generated is saved in a file instead of
|
|
;; sending to printer. To spool the PostScript code generated you need
|
|
;; to turn on the option 16. This option is enabled if spooling is on
|
|
;; (option 16). See also the NOTE 1, NOTE 2 and NOTE 3 on option 1.
|
|
;;
|
|
;; 3. You can select a new PostScript printer to send PostScript code
|
|
;; generated. For selection it's used all PostScript printers defined
|
|
;; in `pr-ps-printer-alist' variable (see it for documentation).
|
|
;; See also `pr-setting-database'.
|
|
;;
|
|
;; II. Text printing:
|
|
;;
|
|
;; 4. If you have control characters (character code from \000 to \037) in a
|
|
;; buffer and you want to print them in a text printer, select this
|
|
;; option. All control characters in your buffer or region will be
|
|
;; replaced by a printable representation. The printable representations
|
|
;; use ^ (for ASCII control characters) or hex. The characters tab,
|
|
;; linefeed, space, return and formfeed are not affected. You don't need
|
|
;; to select this option if you use any option of section I, the
|
|
;; PostScript engine treats control characters properly.
|
|
;;
|
|
;; 5. If you want to print a directory, buffer, region or major mode in a
|
|
;; text printer, select this option. See also the NOTE 1 on option 1.
|
|
;;
|
|
;; 6. You can select a new text printer to send text generated. For
|
|
;; selection it's used all text printers defined in
|
|
;; `pr-txt-printer-alist' variable (see it for documentation).
|
|
;; See also `pr-setting-database'.
|
|
;;
|
|
;; III. PostScript page toggle options:
|
|
;;
|
|
;; 7. If you want a PostScript landscape printing, turn on this option.
|
|
;;
|
|
;; 8. If you want to have a header in each page in your PostScript code,
|
|
;; turn on this option.
|
|
;;
|
|
;; 9. If you want to draw a gaudy frame around the header, turn on this
|
|
;; option. This option is enabled if print header is on (option 8).
|
|
;;
|
|
;; 10. If you want that the line number is printed in your PostScript code,
|
|
;; turn on this option.
|
|
;;
|
|
;; 11. If you want background zebra stripes in your PostScript code, turn on
|
|
;; this option.
|
|
;;
|
|
;; 12. If you want a duplex printing and your PostScript printer has this
|
|
;; feature, turn on this option.
|
|
;;
|
|
;; 13. If you turned on duplex printing, you can choose if you want to have
|
|
;; a printing suitable for binding on the left or right (tumble off), or
|
|
;; to have a printing suitable for binding at top or bottom (tumble on).
|
|
;; This option is enabled if duplex is on (option 12).
|
|
;;
|
|
;; 14. If you want a PostScript upside-down printing, turn on this option.
|
|
;;
|
|
;; 15. With this option, you can choose if you want to print all pages, odd
|
|
;; pages, even pages, odd sheets or even sheets.
|
|
;; See also `ps-even-or-odd-pages'.
|
|
;;
|
|
;; IV. PostScript processing toggle options:
|
|
;;
|
|
;; 16. If you want to spool the PostScript code generated, turn on this
|
|
;; option. To spool the PostScript code generated use option 2. You
|
|
;; can despool later by choosing option 1 or 2, sub-option `Despool...'.
|
|
;;
|
|
;; 17. If you use colors in your buffers and want to see these colors on
|
|
;; your PostScript code generated, turn on this option. If you have a
|
|
;; black/white PostScript printer, these colors are displayed in gray
|
|
;; scale by PostScript printer interpreter.
|
|
;;
|
|
;; 18. If you don't have a PostScript printer to send PostScript files, turn
|
|
;; on this option. When this option is on, the ghostscript is used to
|
|
;; print PostScript files. In GNU or Unix system, if ghostscript is set
|
|
;; as a PostScript filter, you don't need to turn on this option.
|
|
;;
|
|
;; V. Printing customization:
|
|
;;
|
|
;; 19. If you want that region is automagically detected, turn on this
|
|
;; option. Note that this will only work if you're using transient mark
|
|
;; mode. When this option is on, the `*-buffer*' commands will behave
|
|
;; like `*-region*' commands, that is, `*-buffer*' commands will print
|
|
;; only the region marked instead of all buffer.
|
|
;;
|
|
;; 20. Turn this option on if you want that when current major-mode is
|
|
;; declared in `pr-mode-alist', the `*-buffer*' and `*-region*' commands
|
|
;; behave like `*-mode*' commands.
|
|
;;
|
|
;; 21. If you want that Printing menu stays open while you are setting
|
|
;; toggle options, turn on this option. The variables
|
|
;; `pr-menu-char-height' and `pr-menu-char-width' are used to guess the
|
|
;; menu position, so don't forget to adjust these variables if menu
|
|
;; position is not ok.
|
|
;;
|
|
;; VI. Customization:
|
|
;;
|
|
;; 22. Besides all options in section III, IV and V, you can customize much
|
|
;; more PostScript options in `ps-print' option. Or you can customize
|
|
;; some `lpr' options for text printing. Or customize `printing'
|
|
;; options.
|
|
;;
|
|
;; 23. Show current settings for `printing', `ps-print' or `lpr'.
|
|
;;
|
|
;; 24. Quick help for printing menu layout.
|
|
;;
|
|
;;
|
|
;; Option Settings
|
|
;; ---------------
|
|
;;
|
|
;; Below it's shown only the main options that affect all `printing' package.
|
|
;; Check all the settings below *BEFORE* running `printing' commands.
|
|
;;
|
|
;; * Example of setting for GNU or Unix system:
|
|
;;
|
|
;; (require 'printing)
|
|
;; (setq pr-path-alist
|
|
;; '((unix "." "~/bin" ghostview mpage PATH)
|
|
;; (ghostview "$HOME/bin/gsview-dir")
|
|
;; (mpage "$HOME/bin/mpage-dir")
|
|
;; ))
|
|
;; (setq pr-txt-name 'prt_06a)
|
|
;; (setq pr-txt-printer-alist
|
|
;; '((prt_06a "lpr" nil "prt_06a")
|
|
;; (prt_07c nil nil "prt_07c")
|
|
;; ))
|
|
;; (setq pr-ps-name 'lps_06b)
|
|
;; (setq pr-ps-printer-alist
|
|
;; '((lps_06b "lpr" nil "-P" "lps_06b")
|
|
;; (lps_07c "lpr" nil nil "lps_07c")
|
|
;; (lps_08c nil nil nil "lps_08c")
|
|
;; ))
|
|
;; (setq pr-temp-dir "/tmp/")
|
|
;; (setq pr-gv-command "gv")
|
|
;; (setq pr-gs-command "gs")
|
|
;; (setq pr-gs-switches '("-q -dNOPAUSE -I/usr/share/ghostscript/5.10"))
|
|
;; (setq pr-gs-device "uniprint")
|
|
;; (setq pr-gs-resolution 300)
|
|
;; (setq pr-ps-utility 'mpage)
|
|
;; (setq pr-ps-utility-alist
|
|
;; '((mpage "mpage" nil "-b%s" "-%d" "-l" "-t" "-T" ">" nil)
|
|
;; (psnup "psnup" ("-q") "-P%s" "-%d" "-l" nil nil " " nil
|
|
;; (inherits-from: . no-duplex))
|
|
;; ))
|
|
;; (setq pr-setting-database
|
|
;; '((no-duplex
|
|
;; nil nil nil
|
|
;; (pr-file-duplex . nil)
|
|
;; (pr-file-tumble . nil))
|
|
;; ))
|
|
;; (pr-update-menus t) ; update now printer and utility menus
|
|
;;
|
|
;; * Example of setting for Windows system:
|
|
;;
|
|
;; (require 'printing)
|
|
;; (setq pr-path-alist
|
|
;; '((windows "c:/applications/executables" PATH ghostview mpage)
|
|
;; (ghostview "c:/gs/gsview-dir")
|
|
;; (mpage "c:/mpage-dir")
|
|
;; ))
|
|
;; (setq pr-txt-name 'prt_06a)
|
|
;; (setq pr-txt-printer-alist
|
|
;; '((prt_06a "print" nil "/D:\\\\printers\\prt_06a")
|
|
;; (prt_07c nil nil "/D:\\\\printers\\prt_07c")
|
|
;; (PRN "" nil "PRN")
|
|
;; (standard "redpr.exe" nil "")
|
|
;; ))
|
|
;; (setq pr-ps-name 'lps_06b)
|
|
;; (setq pr-ps-printer-alist
|
|
;; '((lps_06a "print" nil "/D:" "\\\\printers\\lps_06a")
|
|
;; (lps_06b "print" nil nil "\\\\printers\\lps_06b")
|
|
;; (lps_07c "print" nil "" "/D:\\\\printers\\lps_07c")
|
|
;; (lps_08c nil nil nil "\\\\printers\\lps_08c")
|
|
;; (b/w "gsprint" ("-all" "-twoup") "-printer " "b/w-pr-name")
|
|
;; (LPT1 "" nil "" "LPT1:")
|
|
;; (PRN "" nil "" "PRN")
|
|
;; (standard "redpr.exe" nil "" "")
|
|
;; ))
|
|
;; (setq pr-temp-dir "C:/WINDOWS/TEMP/")
|
|
;; (setq pr-gv-command "c:/gs/gsview/gsview32.exe")
|
|
;; (setq pr-gs-command "c:/gs/gswin32.exe")
|
|
;; (setq pr-gs-switches '("-q -dNOPAUSE -Ic:/gs/gs5.50;c:/gs/gs5.50/fonts"))
|
|
;; (setq pr-gs-device "mswinpr2")
|
|
;; (setq pr-gs-resolution 300)
|
|
;; (setq pr-ps-utility 'psnup)
|
|
;; (setq pr-ps-utility-alist
|
|
;; '((psnup "c:/psutils/psnup" ("-q") "-P%s" "-%d" "-l" nil nil " "
|
|
;; nil (inherits-from: . no-duplex))
|
|
;; ))
|
|
;; (setq pr-setting-database
|
|
;; '((no-duplex
|
|
;; nil nil nil
|
|
;; (pr-file-duplex . nil)
|
|
;; (pr-file-tumble . nil))
|
|
;; ))
|
|
;; (pr-update-menus t) ; update now printer and utility menus
|
|
;;
|
|
;; NOTE: Don't forget to download and install the utilities declared on
|
|
;; `pr-ps-utility-alist'.
|
|
;;
|
|
;;
|
|
;; Utilities
|
|
;; ---------
|
|
;;
|
|
;; `printing' package has the following utilities:
|
|
;;
|
|
;; `pr-setup' Return the current `printing' setup.
|
|
;;
|
|
;; `lpr-setup' Return the current `lpr' setup.
|
|
;;
|
|
;; `pr-update-menus' Update utility, PostScript and text printer menus.
|
|
;;
|
|
;; `pr-menu-bind' Install `printing' menu in the menubar.
|
|
;;
|
|
;;
|
|
;; Below are some URL where you can find good utilities.
|
|
;;
|
|
;; * For `printing' package:
|
|
;;
|
|
;; printing `http://www.cpqd.com.br/~vinicius/emacs/printing.el.gz'
|
|
;; ps-print `http://www.cpqd.com.br/~vinicius/emacs/ps-print.tar.gz'
|
|
;;
|
|
;; * For GNU or Unix system:
|
|
;;
|
|
;; gs, gv `http://www.gnu.org/software/ghostscript/ghostscript.html'
|
|
;; enscript `http://people.ssh.fi/mtr/genscript/'
|
|
;; psnup `http://www.knackered.org/angus/psutils/'
|
|
;; mpage `http://www.mesa.nl/pub/mpage/'
|
|
;;
|
|
;; * For Windows system:
|
|
;;
|
|
;; gswin32, gsview32
|
|
;; `http://www.gnu.org/software/ghostscript/ghostscript.html'
|
|
;; gsprint `http://www.cs.wisc.edu/~ghost/gsview/gsprint.htm'.
|
|
;; enscript `http://people.ssh.fi/mtr/genscript/'
|
|
;; psnup `http://gnuwin32.sourceforge.net/packages/psutils.htm'
|
|
;; redmon `http://www.cs.wisc.edu/~ghost/redmon/'
|
|
;;
|
|
;;
|
|
;; Acknowledgments
|
|
;; ---------------
|
|
;;
|
|
;; Thanks to Stefan Monnier <monnier@iro.umontreal.ca> for GNU Emacs and XEmacs
|
|
;; printing menu (in `pr-menu-spec') merging suggestion.
|
|
;;
|
|
;; Thanks to Lennart Borgman <lennart.borgman.073@student.lu.se> for gsprint
|
|
;; suggestion (see tip 5 in section Tips).
|
|
;;
|
|
;; Thanks to Drew Adams <drew.adams@oracle.com> for suggestions:
|
|
;; - directory processing.
|
|
;; - `pr-path-alist' variable.
|
|
;; - doc fix.
|
|
;; - a lot of tests on Windows.
|
|
;;
|
|
;; Thanks to Fred Labrosse <f.labrosse@maths.bath.ac.uk> for XEmacs tests.
|
|
;;
|
|
;; Thanks to Klaus Berndl <klaus.berndl@sdm.de> for invaluable help/debugging
|
|
;; and for suggestions:
|
|
;; - even/odd pages printing.
|
|
;; - ghostscript parameters for `pr-ps-printer-alist'.
|
|
;; - default printer name.
|
|
;; - completion functions.
|
|
;; - automagic region detection.
|
|
;; - menu entry hiding.
|
|
;; - fast fire PostScript printing command.
|
|
;; - `pr-path-style' variable.
|
|
;;
|
|
;; Thanks to Kim F. Storm <storm@filanet.dk> for beta-test and for suggestions:
|
|
;; - PostScript Print and PostScript Print Preview merge.
|
|
;; - Tools/Printing menu.
|
|
;; - replace *-using-preview by *-using-ghostscript.
|
|
;; - printer selection.
|
|
;; - extra parameters for `pr-ps-printer-alist'.
|
|
;;
|
|
;; Thanks to:
|
|
;; Frederic Corne <frederic.corne@erli.fr> print-nt.el
|
|
;; Tom Vogels <tov@ece.cmu.edu> mh-e-init.el
|
|
;; Matthew O. Persico <mpersico@erols.com> win32-ps-print.el
|
|
;; Volker Franz <volker.franz@tuebingen.mpg.de> ps-print-interface.el
|
|
;; And to all people who contributed with them.
|
|
;;
|
|
;;
|
|
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;; Code:
|
|
|
|
|
|
(require 'lpr)
|
|
(require 'ps-print)
|
|
|
|
|
|
(and (string< ps-print-version "6.6.4")
|
|
(error "`printing' requires `ps-print' package version 6.6.4 or later"))
|
|
|
|
|
|
(defconst pr-cygwin-system
|
|
(and ps-windows-system (getenv "OSTYPE")
|
|
(string-match "cygwin" (getenv "OSTYPE"))))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; To avoid compilation gripes
|
|
|
|
|
|
(or (fboundp 'easy-menu-intern) ; hacked from easymenu.el
|
|
(defsubst easy-menu-intern (s)
|
|
(if (stringp s) (intern s) s)))
|
|
|
|
|
|
|
|
(or (fboundp 'subst-char-in-string) ; hacked from subr.el
|
|
(defun subst-char-in-string (fromchar tochar string &optional inplace)
|
|
"Replace FROMCHAR with TOCHAR in STRING each time it occurs.
|
|
Unless optional argument INPLACE is non-nil, return a new string."
|
|
(let ((i (length string))
|
|
(newstr (if inplace string (copy-sequence string))))
|
|
(while (> (setq i (1- i)) 0)
|
|
(if (eq (aref newstr i) fromchar)
|
|
(aset newstr i tochar)))
|
|
newstr)))
|
|
|
|
|
|
(or (fboundp 'make-temp-file) ; hacked from subr.el
|
|
(defun make-temp-file (prefix &optional dir-flag suffix)
|
|
"Create a temporary file.
|
|
The returned file name (created by appending some random characters at the end
|
|
of PREFIX, and expanding against `temporary-file-directory' if necessary),
|
|
is guaranteed to point to a newly created empty file.
|
|
You can then use `write-region' to write new data into the file.
|
|
|
|
If DIR-FLAG is non-nil, create a new empty directory instead of a file.
|
|
|
|
If SUFFIX is non-nil, add that at the end of the file name."
|
|
(let ((umask (default-file-modes))
|
|
file)
|
|
(unwind-protect
|
|
(progn
|
|
;; Create temp files with strict access rights. It's easy to
|
|
;; loosen them later, whereas it's impossible to close the
|
|
;; time-window of loose permissions otherwise.
|
|
(set-default-file-modes ?\700)
|
|
(while (condition-case ()
|
|
(progn
|
|
(setq file
|
|
(make-temp-name
|
|
(expand-file-name prefix temporary-file-directory)))
|
|
(if suffix
|
|
(setq file (concat file suffix)))
|
|
(if dir-flag
|
|
(make-directory file)
|
|
(write-region "" nil file nil 'silent nil 'excl))
|
|
nil)
|
|
(file-already-exists t))
|
|
;; the file was somehow created by someone else between
|
|
;; `make-temp-name' and `write-region', let's try again.
|
|
nil)
|
|
file)
|
|
;; Reset the umask.
|
|
(set-default-file-modes umask)))))
|
|
|
|
|
|
;; GNU Emacs
|
|
(defalias 'pr-e-frame-char-height 'frame-char-height)
|
|
(defalias 'pr-e-frame-char-width 'frame-char-width)
|
|
(defalias 'pr-e-mouse-pixel-position 'mouse-pixel-position)
|
|
;; XEmacs
|
|
(defalias 'pr-x-add-submenu 'add-submenu)
|
|
(defalias 'pr-x-event-function 'event-function)
|
|
(defalias 'pr-x-event-object 'event-object)
|
|
(defalias 'pr-x-find-menu-item 'find-menu-item)
|
|
(defalias 'pr-x-font-height 'font-height)
|
|
(defalias 'pr-x-font-width 'font-width)
|
|
(defalias 'pr-x-get-popup-menu-response 'get-popup-menu-response)
|
|
(defalias 'pr-x-make-event 'make-event)
|
|
(defalias 'pr-x-misc-user-event-p 'misc-user-event-p)
|
|
(defalias 'pr-x-relabel-menu-item 'relabel-menu-item)
|
|
(defalias 'pr-x-event-x-pixel 'event-x-pixel)
|
|
(defalias 'pr-x-event-y-pixel 'event-y-pixel)
|
|
|
|
(cond
|
|
((featurep 'xemacs) ; XEmacs
|
|
(defvar current-menubar nil)
|
|
(defvar current-mouse-event nil)
|
|
(defvar zmacs-region-stays nil)
|
|
(defalias 'pr-f-set-keymap-parents 'set-keymap-parents)
|
|
(defalias 'pr-f-set-keymap-name 'set-keymap-name)
|
|
(defun pr-f-read-string (prompt initial history default)
|
|
(let ((str (read-string prompt initial)))
|
|
(if (and str (not (string= str "")))
|
|
str
|
|
default)))
|
|
(defun pr-keep-region-active ()
|
|
(setq zmacs-region-stays t)))
|
|
|
|
(t ; GNU Emacs
|
|
(defvar deactivate-mark nil)
|
|
(defalias 'pr-f-set-keymap-parents 'set-keymap-parent)
|
|
(defalias 'pr-f-set-keymap-name 'ignore)
|
|
(defalias 'pr-f-read-string 'read-string)
|
|
(defun pr-keep-region-active ()
|
|
(setq deactivate-mark nil))))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Customization Functions
|
|
|
|
|
|
(defun pr-alist-custom-set (symbol value)
|
|
"Set the value of custom variables for printer & utility selection."
|
|
(set symbol value)
|
|
(and (featurep 'printing) ; update only after printing is loaded
|
|
(pr-update-menus t)))
|
|
|
|
|
|
(defun pr-ps-utility-custom-set (symbol value)
|
|
"Update utility menu entry."
|
|
(set symbol value)
|
|
(and (featurep 'printing) ; update only after printing is loaded
|
|
(pr-menu-set-utility-title value)))
|
|
|
|
|
|
(defun pr-ps-name-custom-set (symbol value)
|
|
"Update `PostScript Printer:' menu entry."
|
|
(set symbol value)
|
|
(and (featurep 'printing) ; update only after printing is loaded
|
|
(pr-menu-set-ps-title value)))
|
|
|
|
|
|
(defun pr-txt-name-custom-set (symbol value)
|
|
"Update `Text Printer:' menu entry."
|
|
(set symbol value)
|
|
(and (featurep 'printing) ; update only after printing is loaded
|
|
(pr-menu-set-txt-title value)))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; User Interface (I)
|
|
|
|
|
|
(defgroup printing nil
|
|
"Printing Utilities group."
|
|
:tag "Printing Utilities"
|
|
:link '(emacs-library-link :tag "Source Lisp File" "printing.el")
|
|
:prefix "pr-"
|
|
:version "20"
|
|
:group 'wp
|
|
:group 'postscript)
|
|
|
|
|
|
(defcustom pr-path-style
|
|
(if (and (not pr-cygwin-system)
|
|
ps-windows-system)
|
|
'windows
|
|
'unix)
|
|
"*Specify which path style to use for external commands.
|
|
|
|
Valid values are:
|
|
|
|
windows Windows 9x/NT style (\\)
|
|
|
|
unix Unix style (/)"
|
|
:type '(choice :tag "Path style"
|
|
(const :tag "Windows 9x/NT Style (\\)" :value windows)
|
|
(const :tag "Unix Style (/)" :value unix))
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Internal Functions (I)
|
|
|
|
|
|
(defun pr-dosify-file-name (path)
|
|
"Replace unix-style directory separator character with dos/windows one."
|
|
(interactive "sPath: ")
|
|
(if (eq pr-path-style 'windows)
|
|
(subst-char-in-string ?/ ?\\ path)
|
|
path))
|
|
|
|
|
|
(defun pr-unixify-file-name (path)
|
|
"Replace dos/windows-style directory separator character with unix one."
|
|
(interactive "sPath: ")
|
|
(if (eq pr-path-style 'windows)
|
|
(subst-char-in-string ?\\ ?/ path)
|
|
path))
|
|
|
|
|
|
(defun pr-standard-file-name (path)
|
|
"Ensure the proper directory separator depending on the OS.
|
|
That is, if Emacs is running on DOS/Windows, ensure dos/windows-style directory
|
|
separator; otherwise, ensure unix-style directory separator."
|
|
(if (or pr-cygwin-system ps-windows-system)
|
|
(subst-char-in-string ?/ ?\\ path)
|
|
(subst-char-in-string ?\\ ?/ path)))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; User Interface (II)
|
|
|
|
|
|
(defcustom pr-path-alist
|
|
'((unix PATH)
|
|
(cygwin PATH)
|
|
(windows PATH))
|
|
"*Specify an alist for command paths.
|
|
|
|
It's used to find commands used for printing package, like gv, gs, gsview.exe,
|
|
mpage, print.exe, etc. See also `pr-command' function.
|
|
|
|
Each element has the form:
|
|
|
|
(ENTRY DIRECTORY...)
|
|
|
|
Where:
|
|
|
|
ENTRY It's a symbol, used to identify this entry.
|
|
There must exist at least one of the following entries:
|
|
|
|
unix this entry is used when Emacs is running on GNU or
|
|
Unix system.
|
|
|
|
cygwin this entry is used when Emacs is running on Windows
|
|
95/98/NT/2000 with Cygwin.
|
|
|
|
windows this entry is used when Emacs is running on Windows
|
|
95/98/NT/2000.
|
|
|
|
DIRECTORY It should be a string or a symbol. If it's a symbol, it should
|
|
exist an equal entry in `pr-path-alist'. If it's a string,
|
|
it's considered a directory specification.
|
|
|
|
The directory specification may contain:
|
|
$var environment variable expansion
|
|
~/ tilde expansion
|
|
./ current directory
|
|
../ previous directory
|
|
|
|
For example, let's say the home directory is /home/my and the
|
|
current directory is /home/my/dir, so:
|
|
|
|
THE ENTRY IS EXPANDED TO
|
|
~/entry /home/my/entry
|
|
./entry /home/my/dir/entry
|
|
../entry /home/my/entry
|
|
$HOME/entry /home/my/entry
|
|
$HOME/~/other/../my/entry /home/my/entry
|
|
|
|
SPECIAL SYMBOL: If the symbol `PATH' is used in the directory
|
|
list and there isn't a `PATH' entry in `pr-path-alist' or the
|
|
`PATH' entry has a null directory list, the PATH environment
|
|
variable is used.
|
|
|
|
Examples:
|
|
|
|
* On GNU or Unix system:
|
|
|
|
'((unix \".\" \"~/bin\" ghostview mpage PATH)
|
|
(ghostview \"$HOME/bin/gsview-dir\")
|
|
(mpage \"$HOME/bin/mpage-dir\")
|
|
)
|
|
|
|
* On Windows system:
|
|
|
|
'((windows \"c:/applications/executables\" PATH ghostview mpage)
|
|
(ghostview \"c:/gs/gsview-dir\")
|
|
(mpage \"c:/mpage-dir\")
|
|
)"
|
|
:type '(repeat
|
|
(cons :tag ""
|
|
(symbol :tag "Identifier ")
|
|
(repeat :tag "Directory List"
|
|
(choice :menu-tag "Directory"
|
|
:tag "Directory"
|
|
(string :value "")
|
|
(symbol :value symbol)))))
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-txt-name 'default
|
|
"*Specify a printer for printing a text file.
|
|
|
|
The printer name symbol should be defined on `pr-txt-printer-alist' (see it for
|
|
documentation).
|
|
|
|
This variable should be modified by customization engine. If this variable is
|
|
modified by other means (for example, a lisp function), use `pr-update-menus'
|
|
function (see it for documentation) to update text printer menu."
|
|
:type 'symbol
|
|
:set 'pr-txt-name-custom-set
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-txt-printer-alist
|
|
(list (list 'default lpr-command nil
|
|
(cond ((boundp 'printer-name) printer-name)
|
|
(ps-windows-system "PRN")
|
|
(t nil)
|
|
)))
|
|
;; Examples:
|
|
;; * On GNU or Unix system:
|
|
;; '((prt_06a "lpr" nil "prt_06a")
|
|
;; (prt_07c nil nil "prt_07c")
|
|
;; )
|
|
;; * On Windows system:
|
|
;; '((prt_06a "print" nil "/D:\\\\printers\\prt_06a")
|
|
;; (prt_07c nil nil "/D:\\\\printers\\prt_07c")
|
|
;; (PRN "" nil "PRN")
|
|
;; (standard "redpr.exe" nil "")
|
|
;; )
|
|
"*Specify an alist of all text printers (text printer database).
|
|
|
|
The alist element has the form:
|
|
|
|
(SYMBOL COMMAND SWITCHES NAME)
|
|
|
|
Where:
|
|
|
|
SYMBOL It's a symbol to identify a text printer. It's for
|
|
`pr-txt-name' variable setting and for menu selection.
|
|
Examples:
|
|
'prt_06a
|
|
'my_printer
|
|
|
|
COMMAND Name of the program for printing a text file. On MS-DOS and
|
|
MS-Windows systems, if the value is an empty string, then Emacs
|
|
will write directly to the printer port given by NAME (see text
|
|
below), that is, the NAME should be something like \"PRN\" or
|
|
\"LPT1:\".
|
|
If NAME is something like \"\\\\\\\\host\\\\share-name\" then
|
|
COMMAND shouldn't be an empty string.
|
|
The programs `print' and `nprint' (the standard print programs
|
|
on Windows NT and Novell Netware respectively) are handled
|
|
specially, using NAME as the destination for output; any other
|
|
program is treated like `lpr' except that an explicit filename
|
|
is given as the last argument.
|
|
If COMMAND is nil, it's used the default printing program:
|
|
`print' for Windows system, `lp' for lp system and `lpr' for
|
|
all other systems. See also `pr-path-alist'.
|
|
Examples:
|
|
\"print\"
|
|
\"lpr\"
|
|
\"lp\"
|
|
|
|
SWITCHES List of sexp's to pass as extra options for text printer
|
|
program. It is recommended to set NAME (see text below)
|
|
instead of including an explicit switch on this list.
|
|
Example:
|
|
. for lpr
|
|
'(\"-#3\" \"-l\")
|
|
nil
|
|
|
|
NAME A string that specifies a text printer name.
|
|
On Unix-like systems, a string value should be a name
|
|
understood by lpr's -P option (or lp's -d option).
|
|
On MS-DOS and MS-Windows systems, it is the name of a printer
|
|
device or port. Typical non-default settings would be \"LPT1:\"
|
|
to \"LPT3:\" for parallel printers, or \"COM1\" to \"COM4\" or
|
|
\"AUX\" for serial printers, or \"\\\\\\\\hostname\\\\printer\"
|
|
(or \"/D:\\\\\\\\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. If you want to
|
|
discard the printed output, set this to \"NUL\".
|
|
Examples:
|
|
. for print.exe
|
|
\"/D:\\\\\\\\host\\\\share-name\"
|
|
\"LPT1:\"
|
|
\"PRN\"
|
|
|
|
. for lpr or lp
|
|
\"share-name\"
|
|
|
|
This variable should be modified by customization engine. If this variable is
|
|
modified by other means (for example, a lisp function), use `pr-update-menus'
|
|
function (see it for documentation) to update text printer menu.
|
|
|
|
Examples:
|
|
|
|
* On GNU or Unix system:
|
|
|
|
'((prt_06a \"lpr\" nil \"prt_06a\")
|
|
(prt_07c nil nil \"prt_07c\")
|
|
)
|
|
|
|
* On Windows system:
|
|
|
|
'((prt_06a \"print\" nil \"/D:\\\\\\\\printers\\\\prt_06a\")
|
|
(prt_07c nil nil \"/D:\\\\\\\\printers\\\\prt_07c\")
|
|
(PRN \"\" nil \"PRN\")
|
|
(standard \"redpr.exe\" nil \"\")
|
|
)
|
|
|
|
Useful links:
|
|
|
|
* Information about the print command (print.exe)
|
|
`http://www.computerhope.com/printhlp.htm'
|
|
|
|
* RedMon - Redirection Port Monitor (redpr.exe)
|
|
`http://www.cs.wisc.edu/~ghost/redmon/index.htm'
|
|
|
|
* Redirection Port Monitor (redpr.exe on-line help)
|
|
`http://www.cs.wisc.edu/~ghost/redmon/en/redmon.htm'
|
|
|
|
* UNIX man pages: lpr (or type `man lpr')
|
|
`http://bama.ua.edu/cgi-bin/man-cgi?lpr'
|
|
`http://www.mediacollege.com/cgi-bin/man/page.cgi?section=all&topic=lpr'
|
|
|
|
* UNIX man pages: lp (or type `man lp')
|
|
`http://bama.ua.edu/cgi-bin/man-cgi?lp'
|
|
`http://www.mediacollege.com/cgi-bin/man/page.cgi?section=all&topic=lp'
|
|
"
|
|
:type '(repeat
|
|
(list :tag "Text Printer"
|
|
(symbol :tag "Printer Symbol Name")
|
|
(string :tag "Printer Command")
|
|
(repeat :tag "Printer Switches"
|
|
(sexp :tag "Switch" :value ""))
|
|
(choice :menu-tag "Printer Name"
|
|
:tag "Printer Name"
|
|
(const :tag "None" nil)
|
|
string)))
|
|
:set 'pr-alist-custom-set
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-ps-name 'default
|
|
"*Specify a printer for printing a PostScript file.
|
|
|
|
This printer name symbol should be defined on `pr-ps-printer-alist' (see it for
|
|
documentation).
|
|
|
|
This variable should be modified by customization engine. If this variable is
|
|
modified by other means (for example, a lisp function), use `pr-update-menus'
|
|
function (see it for documentation) to update PostScript printer menu."
|
|
:type 'symbol
|
|
:set 'pr-ps-name-custom-set
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-ps-printer-alist
|
|
(list (list 'default lpr-command nil
|
|
(cond (ps-windows-system nil)
|
|
(ps-lp-system "-d")
|
|
(t "-P"))
|
|
(or (getenv "PRINTER") (getenv "LPDEST") ps-printer-name)))
|
|
;; Examples:
|
|
;; * On GNU or Unix system:
|
|
;; '((lps_06b "lpr" nil "-P" "lps_06b")
|
|
;; (lps_07c "lpr" nil nil "lps_07c")
|
|
;; (lps_08c nil nil nil "lps_08c")
|
|
;; )
|
|
;; * On Windows system:
|
|
;; '((lps_06a "print" nil "/D:" "\\\\printers\\lps_06a")
|
|
;; (lps_06b "print" nil nil "\\\\printers\\lps_06b")
|
|
;; (lps_07c "print" nil "" "/D:\\\\printers\\lps_07c")
|
|
;; (lps_08c nil nil nil "\\\\printers\\lps_08c")
|
|
;; (b/w "gsprint" ("-all" "-twoup") "-printer " "b/w-pr-name")
|
|
;; (LPT1 "" nil "" "LPT1:")
|
|
;; (PRN "" nil "" "PRN")
|
|
;; (standard "redpr.exe" nil "" "")
|
|
;; )
|
|
"*Specify an alist for all PostScript printers (PostScript printer database).
|
|
|
|
The alist element has the form:
|
|
|
|
(SYMBOL COMMAND SWITCHES PRINTER-SWITCH NAME DEFAULT...)
|
|
|
|
Where:
|
|
|
|
SYMBOL It's a symbol to identify a PostScript printer. It's for
|
|
`pr-ps-name' variable setting and for menu selection.
|
|
Examples:
|
|
'prt_06a
|
|
'my_printer
|
|
|
|
COMMAND Name of the 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 given by NAME
|
|
(see text below), that is, the NAME should be something like
|
|
\"PRN\" or \"LPT1:\".
|
|
If NAME is something like \"\\\\\\\\host\\\\share-name\" then
|
|
COMMAND shouldn't be an empty string.
|
|
The programs `print' and `nprint' (the standard print programs
|
|
on Windows NT and Novell Netware respectively) are handled
|
|
specially, using NAME as the destination for output; any other
|
|
program is treated like `lpr' except that an explicit filename
|
|
is given as the last argument.
|
|
If COMMAND is nil, it's used the default printing program:
|
|
`print' for Windows system, `lp' for lp system and `lpr' for
|
|
all other systems. See also `pr-path-alist'.
|
|
Examples:
|
|
\"print\"
|
|
\"lpr\"
|
|
\"lp\"
|
|
\"cp\"
|
|
\"gsprint\"
|
|
|
|
SWITCHES List of sexp's to pass as extra options for PostScript printer
|
|
program. It is recommended to set NAME (see text below)
|
|
instead of including an explicit switch on this list.
|
|
Example:
|
|
. for lpr
|
|
'(\"-#3\" \"-l\")
|
|
nil
|
|
|
|
. for gsprint.exe
|
|
'(\"-all\" \"-twoup\")
|
|
|
|
PRINTER-SWITCH A string that specifies PostScript printer name switch. If
|
|
it's necessary to have a space between PRINTER-SWITCH and NAME,
|
|
it should be inserted at the end of PRINTER-SWITCH string.
|
|
If PRINTER-SWITCH is nil, it's used the default printer name
|
|
switch: `/D:' for Windows system, `-d' for lp system and `-P'
|
|
for all other systems.
|
|
Examples:
|
|
. for lpr
|
|
\"-P \"
|
|
|
|
. for lp
|
|
\"-d \"
|
|
|
|
. for print.exe
|
|
\"/D:\"
|
|
|
|
. for gsprint.exe
|
|
\"-printer \"
|
|
|
|
NAME A string that specifies a PostScript printer name.
|
|
On Unix-like systems, a string value should be a name
|
|
understood by lpr's -P option (or lp's -d option).
|
|
On MS-DOS and MS-Windows systems, it is the name of a printer
|
|
device or port. Typical non-default settings would be \"LPT1:\"
|
|
to \"LPT3:\" for parallel printers, or \"COM1\" to \"COM4\" or
|
|
\"AUX\" for serial printers, or \"\\\\\\\\hostname\\\\printer\"
|
|
(or \"/D:\\\\\\\\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. If you want to
|
|
discard the printed output, set this to \"NUL\".
|
|
Examples:
|
|
. for cp.exe
|
|
\"\\\\\\\\host\\\\share-name\"
|
|
|
|
. for print.exe or gsprint.exe
|
|
\"/D:\\\\\\\\host\\\\share-name\"
|
|
\"\\\\\\\\host\\\\share-name\"
|
|
\"LPT1:\"
|
|
\"PRN\"
|
|
|
|
. for lpr or lp
|
|
\"share-name\"
|
|
|
|
DEFAULT It's a way to set default values when this entry is selected.
|
|
It's a cons like:
|
|
|
|
(VARIABLE . VALUE)
|
|
|
|
That associates VARIABLE with VALUE. when this entry is
|
|
selected, it's executed the following command:
|
|
|
|
(set VARIABLE (eval VALUE))
|
|
|
|
Note that VALUE can be any valid lisp expression. So, don't
|
|
forget to quote symbols and constant lists.
|
|
If VARIABLE is the special keyword `inherits-from:', VALUE must
|
|
be a symbol name setting defined in `pr-setting-database' from
|
|
which the current setting inherits the context. Take care with
|
|
circular inheritance.
|
|
Examples:
|
|
'(ps-landscape-mode . nil)
|
|
'(ps-spool-duplex . t)
|
|
'(pr-gs-device . (my-gs-device t))
|
|
|
|
This variable should be modified by customization engine. If this variable is
|
|
modified by other means (for example, a lisp function), use `pr-update-menus'
|
|
function (see it for documentation) to update PostScript printer menu.
|
|
|
|
Examples:
|
|
|
|
* On GNU or Unix system:
|
|
|
|
'((lps_06b \"lpr\" nil \"-P\" \"lps_06b\")
|
|
(lps_07c \"lpr\" nil nil \"lps_07c\")
|
|
(lps_08c nil nil nil \"lps_08c\")
|
|
)
|
|
|
|
* On Windows system:
|
|
|
|
'((lps_06a \"print\" nil \"/D:\" \"\\\\\\\\printers\\\\lps_06a\")
|
|
(lps_06b \"print\" nil nil \"\\\\\\\\printers\\\\lps_06b\")
|
|
(lps_07c \"print\" nil \"\" \"/D:\\\\\\\\printers\\\\lps_07c\")
|
|
(lps_08c nil nil nil \"\\\\\\\\printers\\\\lps_08c\")
|
|
(b/w1 \"gsprint\" (\"-all\" \"-twoup\") \"-printer \" \"b/w-pr-name\")
|
|
(b/w2 \"gsprint\" (\"-all\" \"-twoup\") nil \"-printer \\\\\\\\printers\\\\lps_06a\")
|
|
(LPT1 \"\" nil \"\" \"LPT1:\")
|
|
(PRN \"\" nil \"\" \"PRN\")
|
|
(standard \"redpr.exe\" nil \"\" \"\")
|
|
)
|
|
|
|
|
|
gsprint:
|
|
|
|
You can use gsprint instead of ghostscript to print monochrome PostScript files
|
|
in Windows. The gsprint utility documentation says that it is more efficient
|
|
than ghostscript to print monochrome PostScript.
|
|
|
|
To print non-monochrome PostScript file, the efficiency of ghostscript is
|
|
similar to gsprint.
|
|
|
|
Also the gsprint utility comes together with gsview distribution.
|
|
|
|
As an example of gsprint declaration:
|
|
|
|
(setq pr-ps-printer-alist
|
|
'((A \"gsprint\" (\"-all\" \"-twoup\") \"-printer \" \"lps_015\")
|
|
(B \"gsprint\" (\"-all\" \"-twoup\") nil \"-printer lps_015\")
|
|
;; some other printer declaration
|
|
))
|
|
|
|
The example above declares that printer A prints all pages (-all) and two pages
|
|
per sheet (-twoup). The printer B declaration does the same as the printer A
|
|
declaration, the only difference is the printer name selection.
|
|
|
|
There are other command line options like:
|
|
|
|
-mono Render in monochrome as 1bit/pixel (only black and white).
|
|
-grey Render in greyscale as 8bits/pixel.
|
|
-color Render in color as 24bits/pixel.
|
|
|
|
The default is `-mono'. So, printer A and B in the example above are using
|
|
implicitly the `-mono' option. Note that in `-mono' no gray tone or color is
|
|
printed, this includes the zebra stripes, that is, in `-mono' the zebra stripes
|
|
are not printed.
|
|
|
|
|
|
Useful links:
|
|
|
|
* GSPRINT - Ghostscript print to Windows printer
|
|
`http://www.cs.wisc.edu/~ghost/gsview/gsprint.htm'
|
|
|
|
* Introduction to Ghostscript
|
|
`http://www.cs.wisc.edu/~ghost/doc/intro.htm'
|
|
|
|
* How to use Ghostscript
|
|
`http://www.cs.wisc.edu/~ghost/doc/cvs/Use.htm'
|
|
|
|
* Information about the print command (print.exe)
|
|
`http://www.computerhope.com/printhlp.htm'
|
|
|
|
* RedMon - Redirection Port Monitor (redpr.exe)
|
|
`http://www.cs.wisc.edu/~ghost/redmon/index.htm'
|
|
|
|
* Redirection Port Monitor (redpr.exe on-line help)
|
|
`http://www.cs.wisc.edu/~ghost/redmon/en/redmon.htm'
|
|
|
|
* UNIX man pages: lpr (or type `man lpr')
|
|
`http://bama.ua.edu/cgi-bin/man-cgi?lpr'
|
|
`http://www.mediacollege.com/cgi-bin/man/page.cgi?section=all&topic=lpr'
|
|
|
|
* UNIX man pages: lp (or type `man lp')
|
|
`http://bama.ua.edu/cgi-bin/man-cgi?lp'
|
|
`http://www.mediacollege.com/cgi-bin/man/page.cgi?section=all&topic=lp'
|
|
|
|
* GNU utilities for Win32 (cp.exe)
|
|
`http://unxutils.sourceforge.net/'
|
|
"
|
|
:type '(repeat
|
|
(list
|
|
:tag "PostScript Printer"
|
|
(symbol :tag "Printer Symbol Name")
|
|
(string :tag "Printer Command")
|
|
(repeat :tag "Printer Switches"
|
|
(sexp :tag "Switch" :value ""))
|
|
(choice :menu-tag "Printer Name Switch"
|
|
:tag "Printer Name Switch"
|
|
(const :tag "None" nil)
|
|
string)
|
|
(choice :menu-tag "Printer Name"
|
|
:tag "Printer Name"
|
|
(const :tag "None" nil)
|
|
string)
|
|
(repeat
|
|
:tag "Default Value List"
|
|
:inline t
|
|
(cons
|
|
:tag ""
|
|
(choice
|
|
:menu-tag "Variable"
|
|
:tag "Variable"
|
|
(const :tag "Landscape" ps-landscape-mode)
|
|
(const :tag "Print Header" ps-print-header)
|
|
(const :tag "Print Header Frame" ps-print-header-frame)
|
|
(const :tag "Line Number" ps-line-number)
|
|
(const :tag "Zebra Stripes" ps-zebra-stripes)
|
|
(const :tag "Duplex" ps-spool-duplex)
|
|
(const :tag "Tumble" ps-spool-tumble)
|
|
(const :tag "Upside-Down" ps-print-upside-down)
|
|
(const :tag "PS File Landscape" pr-file-landscape)
|
|
(const :tag "PS File Duplex" pr-file-duplex)
|
|
(const :tag "PS File Tumble" pr-file-tumble)
|
|
(const :tag "Auto Region" pr-auto-region)
|
|
(const :tag "Auto Mode" pr-auto-mode)
|
|
(const :tag "Ghostscript Device" pr-gs-device)
|
|
(const :tag "Ghostscript Resolution" pr-gs-resolution)
|
|
(const :tag "inherits-from:" inherits-from:)
|
|
(variable :tag "Other"))
|
|
(sexp :tag "Value")))
|
|
))
|
|
:set 'pr-alist-custom-set
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-temp-dir
|
|
(pr-dosify-file-name
|
|
(if (boundp 'temporary-file-directory)
|
|
(symbol-value 'temporary-file-directory)
|
|
;; hacked from `temporary-file-directory' variable in files.el
|
|
(file-name-as-directory
|
|
(or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP")
|
|
(cond (ps-windows-system "c:/temp")
|
|
((memq system-type '(vax-vms axp-vms)) "SYS$SCRATCH:")
|
|
(t "/tmp")
|
|
)))))
|
|
"*Specify a directory for temporary files during printing.
|
|
|
|
See also `pr-ps-temp-file' and `pr-file-modes'."
|
|
:type '(directory :tag "Temporary Directory")
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-ps-temp-file "prspool-"
|
|
"*Specify PostScript temporary file name prefix.
|
|
|
|
See also `pr-temp-dir' and `pr-file-modes'."
|
|
:type '(file :tag "PostScript Temporary File Name")
|
|
:version "21"
|
|
:group 'printing)
|
|
|
|
|
|
;; It uses 0600 as default instead of (default-file-modes).
|
|
;; So, by default, only the session owner have permission to deal with files
|
|
;; generated by `printing'.
|
|
(defcustom pr-file-modes ?\600
|
|
"*Specify the file permission bits for newly created files.
|
|
|
|
It should be an integer; only the low 9 bits are used.
|
|
|
|
See also `pr-temp-dir' and `pr-ps-temp-file'."
|
|
:type '(integer :tag "File Permission Bits")
|
|
:version "21.3"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-gv-command
|
|
(if ps-windows-system
|
|
"gsview32.exe"
|
|
"gv")
|
|
"*Specify path and name of the gsview/gv utility.
|
|
|
|
See also `pr-path-alist'.
|
|
|
|
Useful links:
|
|
|
|
* GNU gv manual
|
|
`http://www.gnu.org/software/gv/manual/gv.html'
|
|
|
|
* GSview Help
|
|
`http://www.cs.wisc.edu/~ghost/gsview/gsviewen.htm'
|
|
|
|
* GSview Help - Common Problems
|
|
`http://www.cs.wisc.edu/~ghost/gsview/gsviewen.htm#Common_Problems'
|
|
|
|
* GSview Readme (compilation & installation)
|
|
`http://www.cs.wisc.edu/~ghost/gsview/Readme.htm'
|
|
|
|
* GSview (main site)
|
|
`http://www.cs.wisc.edu/~ghost/gsview/index.htm'
|
|
|
|
* Ghostscript, Ghostview and GSview
|
|
`http://www.cs.wisc.edu/~ghost/'
|
|
|
|
* Ghostview
|
|
`http://www.cs.wisc.edu/~ghost/gv/index.htm'
|
|
|
|
* gv 3.5, June 1997
|
|
`http://www.cs.wisc.edu/~ghost/gv/gv_doc/gv.html'
|
|
|
|
* MacGSView (MacOS)
|
|
`http://www.cs.wisc.edu/~ghost/macos/index.htm'
|
|
"
|
|
:type '(string :tag "Ghostview Utility")
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-gs-command
|
|
(if ps-windows-system
|
|
"gswin32.exe"
|
|
"gs")
|
|
"*Specify path and name of the ghostscript utility.
|
|
|
|
See also `pr-path-alist'.
|
|
|
|
Useful links:
|
|
|
|
* Ghostscript, Ghostview and GSview
|
|
`http://www.cs.wisc.edu/~ghost/'
|
|
|
|
* Introduction to Ghostscript
|
|
`http://www.cs.wisc.edu/~ghost/doc/intro.htm'
|
|
|
|
* How to use Ghostscript
|
|
`http://www.cs.wisc.edu/~ghost/doc/cvs/Use.htm'
|
|
|
|
* Printer compatibility
|
|
`http://www.cs.wisc.edu/~ghost/doc/printer.htm'
|
|
"
|
|
:type '(string :tag "Ghostscript Utility")
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-gs-switches
|
|
(if ps-windows-system
|
|
'("-q -dNOPAUSE -Ic:/gs/gs5.50;c:/gs/gs5.50/fonts")
|
|
'("-q -dNOPAUSE -I/usr/share/ghostscript/5.10"))
|
|
"*Specify ghostscript switches. See the documentation on GS for more info.
|
|
|
|
It's a list of strings, where each string is one or more ghostscript switches.
|
|
|
|
A note on the gs switches:
|
|
|
|
-q quiet
|
|
-dNOPAUSE don't wait for user intervention
|
|
-Ic:/gs/gs5.50;c:/gs/gs5.50/fonts the directories needed for gs
|
|
-c quit it's added at the end to terminate gs
|
|
|
|
To see ghostscript documentation for more information:
|
|
|
|
* On GNU or Unix system:
|
|
- for full documentation, type: man gs
|
|
- for brief documentation, type: gs -h
|
|
|
|
* On Windows system:
|
|
- for full documentation, see in a browser the file
|
|
c:/gstools/gs5.50/index.html, that is, the file index.html which is
|
|
located in the same directory as gswin32.exe.
|
|
- for brief documentation, type: gswin32.exe -h
|
|
|
|
Useful links:
|
|
|
|
* Introduction to Ghostscript
|
|
`http://www.cs.wisc.edu/~ghost/doc/intro.htm'
|
|
|
|
* How to use Ghostscript
|
|
`http://www.cs.wisc.edu/~ghost/doc/cvs/Use.htm'
|
|
|
|
* Printer compatibility
|
|
`http://www.cs.wisc.edu/~ghost/doc/printer.htm'
|
|
"
|
|
:type '(repeat (string :tag "Ghostscript Switch"))
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-gs-device
|
|
(if ps-windows-system
|
|
"mswinpr2"
|
|
"uniprint")
|
|
"*Specify the ghostscript device switch value (-sDEVICE=).
|
|
|
|
A note on the gs switches:
|
|
|
|
-sDEVICE=djet500 the printer - works with HP DeskJet 540
|
|
|
|
See `pr-gs-switches' for documentation.
|
|
See also `pr-ps-printer-alist'."
|
|
:type '(string :tag "Ghostscript Device")
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-gs-resolution 300
|
|
"*Specify ghostscript resolution switch value (-r).
|
|
|
|
A note on the gs switches:
|
|
|
|
-r300 resolution 300x300
|
|
|
|
See `pr-gs-switches' for documentation.
|
|
See also `pr-ps-printer-alist'."
|
|
:type '(integer :tag "Ghostscript Resolution")
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-print-using-ghostscript nil
|
|
"*Non-nil means print using ghostscript.
|
|
|
|
This is useful if you don't have a PostScript printer, so you could use the
|
|
ghostscript to print a PostScript file.
|
|
|
|
In GNU or Unix system, if ghostscript is set as a PostScript filter, this
|
|
variable should be nil."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-faces-p nil
|
|
"*Non-nil means print with face attributes."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-spool-p nil
|
|
"*Non-nil means spool printing in a buffer."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-file-landscape nil
|
|
"*Non-nil means print PostScript file in landscape orientation."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-file-duplex nil
|
|
"*Non-nil means print PostScript file in duplex mode."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-file-tumble nil
|
|
"*Non-nil means print PostScript file in tumble mode.
|
|
|
|
If tumble is off, produces a printing suitable for binding on the left or
|
|
right.
|
|
If tumble is on, produces a printing suitable for binding at the top or
|
|
bottom."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-auto-region t
|
|
"*Non-nil means region is automagically detected.
|
|
|
|
Note that this will only work if you're using transient mark mode.
|
|
|
|
When this variable is non-nil, the `*-buffer*' commands will behave like
|
|
`*-region*' commands, that is, `*-buffer*' commands will print only the region
|
|
marked instead of all buffer."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-auto-mode t
|
|
"*Non-nil means major-mode specific printing is prefered over normal printing.
|
|
|
|
That is, if current major-mode is declared in `pr-mode-alist', the `*-buffer*'
|
|
and `*-region*' commands will behave like `*-mode*' commands; otherwise,
|
|
`*-buffer*' commands will print the current buffer and `*-region*' commands
|
|
will print the current region."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-mode-alist
|
|
'((mh-folder-mode ; mh summary buffer
|
|
pr-mh-lpr-1 pr-mh-print-1
|
|
2
|
|
(ps-article-author ps-article-subject)
|
|
("/pagenumberstring load" pr-article-date)
|
|
nil
|
|
)
|
|
(mh-letter-mode ; mh letter buffer
|
|
pr-mh-lpr-2 pr-mh-print-2
|
|
2
|
|
(ps-article-author ps-article-subject)
|
|
("/pagenumberstring load" pr-article-date)
|
|
nil
|
|
)
|
|
(rmail-summary-mode ; rmail summary buffer
|
|
pr-rmail-lpr pr-rmail-print
|
|
3
|
|
(ps-article-subject ps-article-author buffer-name)
|
|
nil
|
|
nil
|
|
)
|
|
(rmail-mode ; rmail buffer
|
|
pr-rmail-lpr pr-rmail-print
|
|
3
|
|
(ps-article-subject ps-article-author buffer-name)
|
|
nil
|
|
nil
|
|
)
|
|
(gnus-summary-mode ; gnus summary buffer
|
|
pr-gnus-lpr pr-gnus-print
|
|
3
|
|
(ps-article-subject ps-article-author gnus-newsgroup-name)
|
|
nil
|
|
nil
|
|
)
|
|
(gnus-article-mode ; gnus article buffer
|
|
pr-gnus-lpr pr-gnus-print
|
|
3
|
|
(ps-article-subject ps-article-author gnus-newsgroup-name)
|
|
nil
|
|
nil
|
|
)
|
|
(Info-mode ; Info buffer
|
|
pr-mode-lpr pr-mode-print
|
|
2
|
|
(ps-info-node ps-info-file)
|
|
nil
|
|
nil
|
|
)
|
|
(vm-mode ; vm mode
|
|
pr-vm-lpr pr-vm-print
|
|
3
|
|
(ps-article-subject ps-article-author buffer-name)
|
|
nil
|
|
nil
|
|
)
|
|
)
|
|
"*Specify an alist for a major-mode and printing functions.
|
|
|
|
To customize a major mode printing, just declare the customization in
|
|
`pr-mode-alist' and invoke some of `*-mode*' commands. An example for major
|
|
mode usage is when you're using gnus (or mh, or rmail, etc.) and you're in the
|
|
*Summary* buffer, if you forget to switch to the *Article* buffer before
|
|
printing, you'll get a nicely formatted list of article subjects shows up at
|
|
the printer. With major mode printing you don't need to switch from gnus
|
|
*Summary* buffer first.
|
|
|
|
The elements have the following form:
|
|
|
|
(MAJOR-MODE
|
|
LPR-PRINT PS-PRINT
|
|
HEADER-LINES
|
|
LEFT-HEADER
|
|
RIGHT-HEADER
|
|
KILL-LOCAL-VARIABLE
|
|
DEFAULT...)
|
|
|
|
Where:
|
|
|
|
MAJOR-MODE It's the major mode symbol.
|
|
|
|
LPR-PRINT It's a symbol function for text printing. It's invoked with
|
|
one argument:
|
|
(HEADER-LINES LEFT-HEADER RIGHT-HEADER DEFAULT...).
|
|
|
|
Usually LPR-PRINT function prepares the environment or buffer
|
|
and then call the function `pr-mode-lpr' which it's used to
|
|
process the buffer and send it to text printer.
|
|
|
|
The `pr-mode-lpr' definition is:
|
|
|
|
(pr-mode-lpr HEADER-LIST &optional FROM TO)
|
|
|
|
Where HEADER-LIST is like the argument passed to LPR-PRINT.
|
|
FROM and TO are the beginning and end markers, respectively,
|
|
for a region. If FROM is nil, it's used (point-min); if TO is
|
|
nil, it's used (point-max).
|
|
|
|
PS-PRINT It's a symbol function for PostScript printing. It's invoked
|
|
with 3 arguments: n-up printing, file name and the list:
|
|
(HEADER-LINES LEFT-HEADER RIGHT-HEADER DEFAULT...).
|
|
|
|
Usually PS-PRINT function prepares the environment or buffer
|
|
and then call the function `pr-mode-print' which it's used to
|
|
process the buffer and send it to PostScript printer.
|
|
|
|
The `pr-mode-print' definition is:
|
|
|
|
(pr-mode-print N-UP FILENAME HEADER-LIST &optional FROM TO)
|
|
|
|
Where N-UP, FILENAME and HEADER-LIST are like the arguments
|
|
passed to PS-PRINT. FROM and TO are the beginning and end
|
|
markers, respectively, for a region. If TO is nil, it's used
|
|
(point-max).
|
|
|
|
HEADER-LINES It's the number of header lines; if is nil, it uses
|
|
`ps-header-lines' value.
|
|
|
|
LEFT-HEADER It's the left header part, it's a list of string, variable
|
|
symbol or function symbol (with no argument); if is nil, it
|
|
uses `ps-left-header' value.
|
|
|
|
RIGHT-HEADER It's the right header part, it's a list of string, variable
|
|
symbol or function symbol (with no argument); if is nil, it
|
|
uses `ps-right-header' value.
|
|
|
|
KILL-LOCAL-VARIABLE
|
|
Non-nil means to kill all buffer local variable declared in
|
|
DEFAULT (see below).
|
|
|
|
DEFAULT It's a way to set default values when this entry is selected.
|
|
It's a cons like:
|
|
|
|
(VARIABLE-SYM . VALUE)
|
|
|
|
That associates VARIABLE-SYM with VALUE. when this entry is
|
|
selected, it's executed the following command:
|
|
|
|
(set (make-local-variable VARIABLE-SYM) (eval VALUE))
|
|
|
|
Note that VALUE can be any valid lisp expression. So, don't
|
|
forget to quote symbols and constant lists.
|
|
If VARIABLE is the special keyword `inherits-from:', VALUE must
|
|
be a symbol name setting defined in `pr-setting-database' from
|
|
which the current setting inherits the context. Take care with
|
|
circular inheritance.
|
|
Examples:
|
|
'(ps-landscape-mode . nil)
|
|
'(ps-spool-duplex . t)
|
|
'(pr-gs-device . (my-gs-device t))"
|
|
:type '(repeat
|
|
(list
|
|
:tag ""
|
|
(symbol :tag "Major Mode")
|
|
(function :tag "Text Printing Function")
|
|
(function :tag "PS Printing Function")
|
|
(choice :menu-tag "Number of Header Lines"
|
|
:tag "Number of Header Lines"
|
|
(integer :tag "Number")
|
|
(const :tag "Default Number" nil))
|
|
(repeat :tag "Left Header List"
|
|
(choice :menu-tag "Left Header"
|
|
:tag "Left Header"
|
|
string symbol))
|
|
(repeat :tag "Right Header List"
|
|
(choice :menu-tag "Right Header"
|
|
:tag "Right Header"
|
|
string symbol))
|
|
(boolean :tag "Kill Local Variable At End")
|
|
(repeat
|
|
:tag "Default Value List"
|
|
:inline t
|
|
(cons
|
|
:tag ""
|
|
(choice
|
|
:menu-tag "Variable"
|
|
:tag "Variable"
|
|
(const :tag "Landscape" ps-landscape-mode)
|
|
(const :tag "Print Header" ps-print-header)
|
|
(const :tag "Print Header Frame" ps-print-header-frame)
|
|
(const :tag "Line Number" ps-line-number)
|
|
(const :tag "Zebra Stripes" ps-zebra-stripes)
|
|
(const :tag "Duplex" ps-spool-duplex)
|
|
(const :tag "Tumble" ps-spool-tumble)
|
|
(const :tag "Upside-Down" ps-print-upside-down)
|
|
(const :tag "PS File Landscape" pr-file-landscape)
|
|
(const :tag "PS File Duplex" pr-file-duplex)
|
|
(const :tag "PS File Tumble" pr-file-tumble)
|
|
(const :tag "Auto Region" pr-auto-region)
|
|
(const :tag "Auto Mode" pr-auto-mode)
|
|
(const :tag "Ghostscript Device" pr-gs-device)
|
|
(const :tag "Ghostscript Resolution" pr-gs-resolution)
|
|
(const :tag "inherits-from:" inherits-from:)
|
|
(variable :tag "Other"))
|
|
(sexp :tag "Value")))
|
|
))
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-ps-utility 'mpage
|
|
"*Specify PostScript utility symbol.
|
|
|
|
This utility symbol should be defined on `pr-ps-utility-alist' (see it for
|
|
documentation).
|
|
|
|
This variable should be modified by customization engine. If this variable is
|
|
modified by other means (for example, a lisp function), use `pr-update-menus'
|
|
function (see it for documentation) to update PostScript utility menu.
|
|
|
|
NOTE: Don't forget to download and install the utilities declared on
|
|
`pr-ps-utility-alist'."
|
|
:type '(symbol :tag "PS File Utility")
|
|
:set 'pr-ps-utility-custom-set
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-ps-utility-alist
|
|
'((mpage "mpage" nil "-b%s" "-%d" "-l" "-t" "-T" ">" nil)
|
|
(psnup "psnup" ("-q") "-P%s" "-%d" "-l" nil nil " " nil
|
|
(inherits-from: . no-duplex))
|
|
)
|
|
;; Examples:
|
|
;; * On GNU or Unix system:
|
|
;; '((mpage "mpage" nil "-b%s" "-%d" "-l" "-t" "-T" ">" nil)
|
|
;; (psnup "psnup" ("-q") "-P%s" "-%d" "-l" nil nil " " nil
|
|
;; (pr-file-duplex . nil) (pr-file-tumble . nil))
|
|
;; )
|
|
;; * On Windows system:
|
|
;; '((psnup "c:/psutils/psnup" ("-q") "-P%s" "-%d" "-l" nil nil " " nil
|
|
;; (pr-file-duplex . nil) (pr-file-tumble . nil))
|
|
;; )
|
|
"*Specify an alist for PostScript utility processing (PS utility database).
|
|
|
|
The alist element has the form:
|
|
|
|
(SYMBOL UTILITY MUST-SWITCHES PAPERSIZE N-UP LANDSCAPE DUPLEX TUMBLE OUTPUT
|
|
SWITCHES DEFAULT...)
|
|
|
|
Where:
|
|
|
|
SYMBOL It's a symbol to identify a PostScript utility. It's for
|
|
`pr-ps-utility' variable setting and for menu selection.
|
|
Examples:
|
|
'mpage
|
|
'psnup
|
|
|
|
UTILITY Name of utility for processing a PostScript file.
|
|
See also `pr-path-alist'.
|
|
Examples:
|
|
. for GNU or Unix system:
|
|
\"mpage\"
|
|
\"psnup -q\"
|
|
|
|
. for Windows system:
|
|
\"c:/psutils/psnup -q\"
|
|
|
|
MUST-SWITCHES List of sexp's to pass as options to the PostScript utility
|
|
program. These options are necessary to process the utility
|
|
program and must be placed before any other switches.
|
|
Example:
|
|
. for psnup:
|
|
'(\"-q\")
|
|
|
|
PAPERSIZE It's a format string to specify paper size switch.
|
|
Example:
|
|
. for mpage
|
|
\"-b%s\"
|
|
|
|
N-UP It's a format string to specify n-up switch.
|
|
Example:
|
|
. for psnup
|
|
\"-%d\"
|
|
|
|
LANDSCAPE It's a string to specify landscape switch. If the utility
|
|
doesn't have landscape switch, set to nil.
|
|
Example:
|
|
. for psnup
|
|
\"-l\"
|
|
|
|
DUPLEX It's a string to specify duplex switch. If the utility doesn't
|
|
have duplex switch, set to nil.
|
|
Example:
|
|
. for psnup
|
|
nil
|
|
|
|
TUMBLE It's a string to specify tumble switch. If the utility doesn't
|
|
have tumble switch, set to nil.
|
|
Example:
|
|
. for psnup
|
|
nil
|
|
|
|
OUTPUT It's a string to specify how to generate an output file. Some
|
|
utilities accept an output file option, but some others need
|
|
output redirection or some other way to specify an output file.
|
|
Example:
|
|
. for psnup
|
|
\" \" ; psnup ... input output
|
|
|
|
. for mpage
|
|
\">\" ; mpage ... input > output
|
|
|
|
SWITCHES List of sexp's to pass as extra options to the PostScript utility
|
|
program.
|
|
Example:
|
|
. for psnup
|
|
'(\"-q\")
|
|
nil
|
|
|
|
DEFAULT It's a way to set default values when this entry is selected.
|
|
It's a cons like:
|
|
|
|
(VARIABLE . VALUE)
|
|
|
|
That associates VARIABLE with VALUE. when this entry is
|
|
selected, it's executed the following command:
|
|
|
|
(set VARIABLE (eval VALUE))
|
|
|
|
Note that VALUE can be any valid lisp expression. So, don't
|
|
forget to quote symbols and constant lists.
|
|
If VARIABLE is the special keyword `inherits-from:', VALUE must
|
|
be a symbol name setting defined in `pr-setting-database' from
|
|
which the current setting inherits the context. Take care with
|
|
circular inheritance.
|
|
Examples:
|
|
'(pr-file-landscape . nil)
|
|
'(pr-file-duplex . t)
|
|
'(pr-gs-device . (my-gs-device t))
|
|
|
|
This variable should be modified by customization engine. If this variable is
|
|
modified by other means (for example, a lisp function), use `pr-update-menus'
|
|
function (see it for documentation) to update PostScript utility menu.
|
|
|
|
NOTE: Don't forget to download and install the utilities declared on
|
|
`pr-ps-utility-alist'.
|
|
|
|
Examples:
|
|
|
|
* On GNU or Unix system:
|
|
|
|
'((mpage \"mpage\" nil \"-b%s\" \"-%d\" \"-l\" \"-t\" \"-T\" \">\" nil)
|
|
(psnup \"psnup\" (\"-q\") \"-P%s\" \"-%d\" \"-l\" nil nil \" \" nil
|
|
(pr-file-duplex . nil) (pr-file-tumble . nil))
|
|
)
|
|
|
|
* On Windows system:
|
|
|
|
'((psnup \"c:/psutils/psnup\" (\"-q\") \"-P%s\" \"-%d\" \"-l\" nil nil \" \"
|
|
nil (pr-file-duplex . nil) (pr-file-tumble . nil))
|
|
)
|
|
|
|
Useful links:
|
|
|
|
* mpage download (GNU or Unix)
|
|
`http://www.mesa.nl/pub/mpage/'
|
|
|
|
* mpage documentation (GNU or Unix - or type `man mpage')
|
|
`http://www.cs.umd.edu/faq/guides/manual_unix/node48.html'
|
|
`http://www.rt.com/man/mpage.1.html'
|
|
|
|
* psnup (Windows, GNU or Unix)
|
|
`http://www.knackered.org/angus/psutils/'
|
|
`http://gershwin.ens.fr/vdaniel/Doc-Locale/Outils-Gnu-Linux/PsUtils/'
|
|
|
|
* psnup (PsUtils for Windows)
|
|
`http://gnuwin32.sourceforge.net/packages/psutils.htm'
|
|
|
|
* psnup documentation (GNU or Unix - or type `man psnup')
|
|
`http://linux.about.com/library/cmd/blcmdl1_psnup.htm'
|
|
`http://amath.colorado.edu/computing/software/man/psnup.html'
|
|
|
|
* GNU Enscript (Windows, GNU or Unix)
|
|
`http://people.ssh.com/mtr/genscript/'
|
|
|
|
* GNU Enscript documentation (Windows, GNU or Unix)
|
|
`http://people.ssh.com/mtr/genscript/enscript.man.html'
|
|
(on GNU or Unix, type `man enscript')
|
|
"
|
|
:type '(repeat
|
|
(list :tag "PS File Utility"
|
|
(symbol :tag "Utility Symbol")
|
|
(string :tag "Utility Name")
|
|
(repeat :tag "Must Utility Switches"
|
|
(sexp :tag "Switch" :value ""))
|
|
(choice :menu-tag "Paper Size"
|
|
:tag "Paper Size"
|
|
(const :tag "No Paper Size" nil)
|
|
(string :tag "Paper Size Format"))
|
|
(choice :menu-tag "N-Up"
|
|
:tag "N-Up"
|
|
(const :tag "No N-Up" nil)
|
|
(string :tag "N-Up Format"))
|
|
(choice :menu-tag "Landscape"
|
|
:tag "Landscape"
|
|
(const :tag "No Landscape" nil)
|
|
(string :tag "Landscape Switch"))
|
|
(choice :menu-tag "Duplex"
|
|
:tag "Duplex"
|
|
(const :tag "No Duplex" nil)
|
|
(string :tag "Duplex Switch"))
|
|
(choice :menu-tag "Tumble"
|
|
:tag "Tumble"
|
|
(const :tag "No Tumble" nil)
|
|
(string :tag "Tumble Switch"))
|
|
(string :tag "Output Separator")
|
|
(repeat :tag "Utility Switches"
|
|
(sexp :tag "Switch" :value ""))
|
|
(repeat
|
|
:tag "Default Value List"
|
|
:inline t
|
|
(cons
|
|
:tag ""
|
|
(choice
|
|
:menu-tag "Variable"
|
|
:tag "Variable"
|
|
(const :tag "PS File Landscape" pr-file-landscape)
|
|
(const :tag "PS File Duplex" pr-file-duplex)
|
|
(const :tag "PS File Tumble" pr-file-tumble)
|
|
(const :tag "Ghostscript Device" pr-gs-device)
|
|
(const :tag "Ghostscript Resolution" pr-gs-resolution)
|
|
(const :tag "inherits-from:" inherits-from:)
|
|
(variable :tag "Other"))
|
|
(sexp :tag "Value")))
|
|
))
|
|
:set 'pr-alist-custom-set
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-menu-lock t
|
|
"*Non-nil means menu is locked while selecting toggle options.
|
|
|
|
See also `pr-menu-char-height' and `pr-menu-char-width'."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-menu-char-height
|
|
(cond ((featurep 'xemacs) ; XEmacs
|
|
(pr-x-font-height (face-font 'default)))
|
|
(t ; GNU Emacs
|
|
(pr-e-frame-char-height)))
|
|
"*Specify menu char height in pixels.
|
|
|
|
This variable is used to guess which vertical position should be locked the
|
|
menu, so don't forget to adjust it if menu position is not ok.
|
|
|
|
See also `pr-menu-lock' and `pr-menu-char-width'."
|
|
:type 'integer
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-menu-char-width
|
|
(cond ((featurep 'xemacs) ; XEmacs
|
|
(pr-x-font-width (face-font 'default)))
|
|
(t ; GNU Emacs
|
|
(pr-e-frame-char-width)))
|
|
"*Specify menu char width in pixels.
|
|
|
|
This variable is used to guess which horizontal position should be locked the
|
|
menu, so don't forget to adjust it if menu position is not ok.
|
|
|
|
See also `pr-menu-lock' and `pr-menu-char-height'."
|
|
:type 'integer
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-setting-database
|
|
'((no-duplex ; setting symbol name
|
|
nil nil nil ; inherits local kill-local
|
|
(pr-file-duplex . nil) ; settings
|
|
(pr-file-tumble . nil))
|
|
)
|
|
"*Specify an alist for settings in general.
|
|
|
|
The elements have the following form:
|
|
|
|
(SYMBOL INHERITS LOCAL KILL-LOCAL SETTING...)
|
|
|
|
Where:
|
|
|
|
SYMBOL It's a symbol to identify the setting group.
|
|
|
|
INHERITS Specify the inheritance for SYMBOL group. It's a symbol name
|
|
setting from which the current setting inherits the context.
|
|
If INHERITS is nil, means that there is no inheritance.
|
|
This is a simple inheritance mechanism.
|
|
|
|
Let's see an example to illustrate the inheritance mechanism:
|
|
|
|
(setq pr-setting-database
|
|
'((no-duplex ; setting symbol name
|
|
nil ; inherits
|
|
nil nil ; local kill-local
|
|
(pr-file-duplex . nil) ; settings
|
|
(pr-file-tumble . nil)
|
|
)
|
|
(no-duplex-and-landscape ; setting symbol name
|
|
no-duplex ; inherits
|
|
nil nil ; local kill-local
|
|
(pr-file-landscape . nil) ; settings
|
|
)))
|
|
|
|
The example above has two setting groups: no-duplex and
|
|
no-duplex-and-landscape. When setting no-duplex is activated
|
|
through `inherits-from:' (see `pr-ps-utility', `pr-mode-alist'
|
|
and `pr-ps-printer-alist'), the variables pr-file-duplex and
|
|
pr-file-tumble are both set to nil.
|
|
|
|
Now when setting no-duplex-and-landscape is activated through
|
|
`inherits-from:', the variable pr-file-landscape is set to nil
|
|
and also the settings for no-duplex are done, because
|
|
no-duplex-and-landscape inherits settings from no-duplex.
|
|
|
|
Take care with circular inheritance. It's an error if circular
|
|
inheritance happens.
|
|
|
|
LOCAL Non-nil means that all settings for SYMBOL group will be
|
|
declared local buffer.
|
|
|
|
KILL-LOCAL Non-nil means that all settings for SYMBOL group will be
|
|
killed at end. It has effect only when LOCAL is non-nil.
|
|
|
|
SETTING It's a cons like:
|
|
|
|
(VARIABLE . VALUE)
|
|
|
|
That associates VARIABLE with VALUE. when this entry is
|
|
selected, it's executed the following command:
|
|
|
|
* If LOCAL is non-nil:
|
|
(set (make-local-variable VARIABLE) (eval VALUE))
|
|
|
|
* If LOCAL is nil:
|
|
(set VARIABLE (eval VALUE))
|
|
|
|
Note that VALUE can be any valid lisp expression. So, don't
|
|
forget to quote symbols and constant lists.
|
|
This setting is ignored if VARIABLE is equal to keyword
|
|
`inherits-from:'.
|
|
Examples:
|
|
'(ps-landscape-mode . nil)
|
|
'(ps-spool-duplex . t)
|
|
'(pr-gs-device . (my-gs-device t))"
|
|
:type '(repeat
|
|
(list
|
|
:tag ""
|
|
(symbol :tag "Setting Name")
|
|
(choice :menu-tag "Inheritance"
|
|
:tag "Inheritance"
|
|
(const :tag "No Inheritance" nil)
|
|
(symbol :tag "Inherits From"))
|
|
(boolean :tag "Local Buffer Setting")
|
|
(boolean :tag "Kill Local Variable At End")
|
|
(repeat
|
|
:tag "Setting List"
|
|
:inline t
|
|
(cons
|
|
:tag ""
|
|
(choice
|
|
:menu-tag "Variable"
|
|
:tag "Variable"
|
|
(const :tag "Landscape" ps-landscape-mode)
|
|
(const :tag "Print Header" ps-print-header)
|
|
(const :tag "Print Header Frame" ps-print-header-frame)
|
|
(const :tag "Line Number" ps-line-number)
|
|
(const :tag "Zebra Stripes" ps-zebra-stripes)
|
|
(const :tag "Duplex" ps-spool-duplex)
|
|
(const :tag "Tumble" ps-spool-tumble)
|
|
(const :tag "Upside-Down" ps-print-upside-down)
|
|
(const :tag "PS File Landscape" pr-file-landscape)
|
|
(const :tag "PS File Duplex" pr-file-duplex)
|
|
(const :tag "PS File Tumble" pr-file-tumble)
|
|
(const :tag "Auto Region" pr-auto-region)
|
|
(const :tag "Auto Mode" pr-auto-mode)
|
|
(const :tag "Ghostscript Device" pr-gs-device)
|
|
(const :tag "Ghostscript Resolution" pr-gs-resolution)
|
|
(variable :tag "Other"))
|
|
(sexp :tag "Value")))
|
|
))
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-visible-entry-list
|
|
'(postscript text postscript-options postscript-process printing help)
|
|
"*Specify a list of Printing menu visible entries.
|
|
|
|
Valid values with the corresponding menu parts are:
|
|
|
|
+------------------------------+
|
|
| Printing Interface |
|
|
+------------------------------+
|
|
`postscript' | PostScript Preview >|
|
|
| PostScript Print >|
|
|
| PostScript Printer: name >|
|
|
+------------------------------+
|
|
`text' | Printify >|
|
|
| Print >|
|
|
| Text Printer: name >|
|
|
+------------------------------+
|
|
`postscript-options' |[ ] Landscape |
|
|
|[ ] Print Header |
|
|
|[ ] Print Header Frame |
|
|
|[ ] Line Number |
|
|
|[ ] Zebra Stripes |
|
|
|[ ] Duplex |
|
|
|[ ] Tumble |
|
|
|[ ] Upside-Down |
|
|
| Print All Pages >|
|
|
+------------------------------+
|
|
`postscript-process' |[ ] Spool Buffer |
|
|
|[ ] Print with faces |
|
|
|[ ] Print via Ghostscript |
|
|
+------------------------------+
|
|
`printing' |[ ] Auto Region |
|
|
|[ ] Auto Mode |
|
|
|[ ] Menu Lock |
|
|
+------------------------------+
|
|
`help' | Customize >|
|
|
| Show Settings >|
|
|
| Help |
|
|
+------------------------------+
|
|
|
|
Any other value is ignored."
|
|
:type '(repeat :tag "Menu Visible Part"
|
|
(choice :menu-tag "Menu Part"
|
|
:tag "Menu Part"
|
|
(const postscript)
|
|
(const text)
|
|
(const postscript-options)
|
|
(const postscript-process)
|
|
(const printing)
|
|
(const help)))
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-delete-temp-file t
|
|
"*Non-nil means delete temporary files.
|
|
|
|
Set `pr-delete-temp-file' to nil, if the following message (or a similar)
|
|
happens when printing:
|
|
|
|
Error: could not open \"c:\\temp\\prspool.ps\" for reading."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-list-directory nil
|
|
"*Non-nil means list directory when processing a directory.
|
|
|
|
That is, any subdirectories (and the superdirectory) of the directory (given as
|
|
argument of functions below) are also printed (as dired-mode listings).
|
|
|
|
It's used by `pr-ps-directory-preview', `pr-ps-directory-using-ghostscript',
|
|
`pr-ps-directory-print', `pr-ps-directory-ps-print', `pr-printify-directory'
|
|
and `pr-txt-directory'."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-buffer-name "*Printing Interface*"
|
|
"*Specify the name of the buffer interface for printing package.
|
|
|
|
It's used by `pr-interface'."
|
|
:type 'string
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-buffer-name-ignore
|
|
(list (regexp-quote pr-buffer-name) ; ignore printing interface buffer
|
|
"^ .*$") ; ignore invisible buffers
|
|
"*Specify a regexp list for buffer names to be ignored in interface buffer.
|
|
|
|
NOTE: Case is important for matching, that is, `case-fold-search' is always
|
|
nil.
|
|
|
|
It's used by `pr-interface'."
|
|
:type '(repeat (regexp :tag "Buffer Name Regexp"))
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
(defcustom pr-buffer-verbose t
|
|
"*Non-nil means to be verbose when editing a field in interface buffer.
|
|
|
|
It's used by `pr-interface'."
|
|
:type 'boolean
|
|
:version "20"
|
|
:group 'printing)
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Internal Variables
|
|
|
|
|
|
(defvar pr-txt-command nil
|
|
"Name of program for printing a text file.
|
|
See `pr-txt-printer-alist'.")
|
|
|
|
|
|
(defvar pr-txt-switches nil
|
|
"List of sexp's to pass as extra options to the text printer program.
|
|
See `pr-txt-printer-alist'.")
|
|
|
|
|
|
(defvar pr-txt-printer nil
|
|
"Specify text printer name.
|
|
See `pr-txt-printer-alist'.")
|
|
|
|
|
|
(defvar pr-ps-command nil
|
|
"Name of program for printing a PostScript file.
|
|
See `pr-ps-printer-alist'.")
|
|
|
|
|
|
(defvar pr-ps-switches nil
|
|
"List of sexp's to pass as extra options to the PostScript printer program.
|
|
See `pr-ps-printer-alist'.")
|
|
|
|
|
|
(defvar pr-ps-printer-switch nil
|
|
"Specify PostScript printer name switch.
|
|
See `pr-ps-printer-alist'.")
|
|
|
|
|
|
(defvar pr-ps-printer nil
|
|
"Specify PostScript printer name.
|
|
See `pr-ps-printer-alist'.")
|
|
|
|
|
|
(defvar pr-menu-bar nil
|
|
"Specify Printing menu-bar entry.")
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Macros
|
|
|
|
|
|
(defmacro pr-save-file-modes (&rest body)
|
|
"Set temporally file modes to `pr-file-modes'."
|
|
`(let ((pr--default-file-modes (default-file-modes))) ; save default
|
|
(set-default-file-modes pr-file-modes)
|
|
,@body
|
|
(set-default-file-modes pr--default-file-modes))) ; restore default
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Keys & Menus
|
|
|
|
|
|
(defmacro pr-xemacs-global-menubar (&rest body)
|
|
`(save-excursion
|
|
(let ((temp (get-buffer-create (make-temp-name " *Temp"))))
|
|
;; be sure to access global menubar
|
|
(set-buffer temp)
|
|
,@body
|
|
(kill-buffer temp))))
|
|
|
|
|
|
(defsubst pr-visible-p (key)
|
|
(memq key pr-visible-entry-list))
|
|
|
|
|
|
(defsubst pr-mode-alist-p ()
|
|
(cdr (assq major-mode pr-mode-alist)))
|
|
|
|
|
|
(defsubst pr-auto-mode-p ()
|
|
(and pr-auto-mode (pr-mode-alist-p)))
|
|
|
|
|
|
(defsubst pr-using-ghostscript-p ()
|
|
(and pr-print-using-ghostscript (not pr-spool-p)))
|
|
|
|
|
|
(defun pr-get-symbol (name)
|
|
(easy-menu-intern name))
|
|
|
|
(cond
|
|
((featurep 'xemacs) ; XEmacs
|
|
(defvar zmacs-region-stays nil) ; to avoid compilation gripes
|
|
(defun pr-region-active-p ()
|
|
(and pr-auto-region (not zmacs-region-stays) (ps-mark-active-p))))
|
|
|
|
(t ; GNU Emacs
|
|
(defun pr-region-active-p ()
|
|
(and pr-auto-region transient-mark-mode mark-active))))
|
|
|
|
|
|
(defconst pr-menu-spec
|
|
;; Menu mapping:
|
|
;; unfortunately XEmacs doesn't support :active for submenus,
|
|
;; only for items.
|
|
;; So, it uses :included instead of :active.
|
|
;; Also, XEmacs doesn't support :help tag.
|
|
(let ((pr-:active (if (featurep 'xemacs)
|
|
:included ; XEmacs
|
|
:active)) ; GNU Emacs
|
|
(pr-:help (if (featurep 'xemacs)
|
|
'ignore ; XEmacs
|
|
#'(lambda (text) (list :help text))))) ; GNU Emacs
|
|
`(
|
|
["Printing Interface" pr-interface
|
|
,@(funcall
|
|
pr-:help "Use buffer interface instead of menu interface")]
|
|
"--"
|
|
("PostScript Preview" :included (pr-visible-p 'postscript)
|
|
,@(funcall
|
|
pr-:help "Preview PostScript instead of sending to printer")
|
|
("Directory" ,pr-:active (not pr-spool-p)
|
|
["1-up" (pr-ps-directory-preview 1 nil nil t) t]
|
|
["2-up" (pr-ps-directory-preview 2 nil nil t) t]
|
|
["4-up" (pr-ps-directory-preview 4 nil nil t) t]
|
|
["Other..." (pr-ps-directory-preview nil nil nil t)
|
|
:keys "\\[pr-ps-buffer-preview]"])
|
|
("Buffer" ,pr-:active (not pr-spool-p)
|
|
["1-up" (pr-ps-buffer-preview 1 t) t]
|
|
["2-up" (pr-ps-buffer-preview 2 t) t]
|
|
["4-up" (pr-ps-buffer-preview 4 t) t]
|
|
["Other..." (pr-ps-buffer-preview nil t)
|
|
:keys "\\[pr-ps-buffer-preview]"])
|
|
("Region" ,pr-:active (and (not pr-spool-p) (ps-mark-active-p))
|
|
["1-up" (pr-ps-region-preview 1 t) t]
|
|
["2-up" (pr-ps-region-preview 2 t) t]
|
|
["4-up" (pr-ps-region-preview 4 t) t]
|
|
["Other..." (pr-ps-region-preview nil t)
|
|
:keys "\\[pr-ps-region-preview]"])
|
|
("Mode" ,pr-:active (and (not pr-spool-p) (pr-mode-alist-p))
|
|
["1-up" (pr-ps-mode-preview 1 t) t]
|
|
["2-up" (pr-ps-mode-preview 2 t) t]
|
|
["4-up" (pr-ps-mode-preview 4 t) t]
|
|
["Other..." (pr-ps-mode-preview nil t)
|
|
:keys "\\[pr-ps-mode-preview]"])
|
|
("File"
|
|
["No Preprocessing..." (call-interactively 'pr-ps-file-preview)
|
|
:keys "\\[pr-ps-file-preview]"
|
|
,@(funcall
|
|
pr-:help "Preview PostScript file")]
|
|
"--"
|
|
["PostScript Utility" pr-update-menus :active pr-ps-utility-alist
|
|
,@(funcall
|
|
pr-:help "Select PostScript utility")]
|
|
"--"
|
|
["1-up..." (pr-ps-file-up-preview 1 t t) pr-ps-utility-alist]
|
|
["2-up..." (pr-ps-file-up-preview 2 t t) pr-ps-utility-alist]
|
|
["4-up..." (pr-ps-file-up-preview 4 t t) pr-ps-utility-alist]
|
|
["Other..." (pr-ps-file-up-preview nil t t)
|
|
:keys "\\[pr-ps-file-up-preview]" :active pr-ps-utility-alist]
|
|
"--"
|
|
["Landscape" pr-toggle-file-landscape-menu
|
|
:style toggle :selected pr-file-landscape
|
|
,@(funcall
|
|
pr-:help "Toggle landscape for PostScript file")
|
|
:active pr-ps-utility-alist]
|
|
["Duplex" pr-toggle-file-duplex-menu
|
|
:style toggle :selected pr-file-duplex
|
|
,@(funcall
|
|
pr-:help "Toggle duplex for PostScript file")
|
|
:active pr-ps-utility-alist]
|
|
["Tumble" pr-toggle-file-tumble-menu
|
|
:style toggle :selected pr-file-tumble
|
|
,@(funcall
|
|
pr-:help "Toggle tumble for PostScript file")
|
|
:active (and pr-file-duplex pr-ps-utility-alist)])
|
|
["Despool..." (call-interactively 'pr-despool-preview)
|
|
:active pr-spool-p :keys "\\[pr-despool-preview]"
|
|
,@(funcall
|
|
pr-:help "Despool PostScript buffer to printer or file (C-u)")])
|
|
("PostScript Print" :included (pr-visible-p 'postscript)
|
|
,@(funcall
|
|
pr-:help "Send PostScript to printer or file (C-u)")
|
|
("Directory"
|
|
["1-up" (pr-ps-directory-ps-print 1 nil nil t) t]
|
|
["2-up" (pr-ps-directory-ps-print 2 nil nil t) t]
|
|
["4-up" (pr-ps-directory-ps-print 4 nil nil t) t]
|
|
["Other..." (pr-ps-directory-ps-print nil nil nil t)
|
|
:keys "\\[pr-ps-buffer-ps-print]"])
|
|
("Buffer"
|
|
["1-up" (pr-ps-buffer-ps-print 1 t) t]
|
|
["2-up" (pr-ps-buffer-ps-print 2 t) t]
|
|
["4-up" (pr-ps-buffer-ps-print 4 t) t]
|
|
["Other..." (pr-ps-buffer-ps-print nil t)
|
|
:keys "\\[pr-ps-buffer-ps-print]"])
|
|
("Region" ,pr-:active (ps-mark-active-p)
|
|
["1-up" (pr-ps-region-ps-print 1 t) t]
|
|
["2-up" (pr-ps-region-ps-print 2 t) t]
|
|
["4-up" (pr-ps-region-ps-print 4 t) t]
|
|
["Other..." (pr-ps-region-ps-print nil t)
|
|
:keys "\\[pr-ps-region-ps-print]"])
|
|
("Mode" ,pr-:active (pr-mode-alist-p)
|
|
["1-up" (pr-ps-mode-ps-print 1 t) t]
|
|
["2-up" (pr-ps-mode-ps-print 2 t) t]
|
|
["4-up" (pr-ps-mode-ps-print 4 t) t]
|
|
["Other..." (pr-ps-mode-ps-print nil t)
|
|
:keys "\\[pr-ps-mode-ps-print]"])
|
|
("File"
|
|
["No Preprocessing..." (call-interactively 'pr-ps-file-ps-print)
|
|
:keys "\\[pr-ps-file-ps-print]"
|
|
,@(funcall
|
|
pr-:help "Send PostScript file to printer")]
|
|
"--"
|
|
["PostScript Utility" pr-update-menus :active pr-ps-utility-alist
|
|
,@(funcall
|
|
pr-:help "Select PostScript utility")]
|
|
"--"
|
|
["1-up..." (pr-ps-file-up-ps-print 1 t t) pr-ps-utility-alist]
|
|
["2-up..." (pr-ps-file-up-ps-print 2 t t) pr-ps-utility-alist]
|
|
["4-up..." (pr-ps-file-up-ps-print 4 t t) pr-ps-utility-alist]
|
|
["Other..." (pr-ps-file-up-ps-print nil t t)
|
|
:keys "\\[pr-ps-file-up-ps-print]" :active pr-ps-utility-alist]
|
|
"--"
|
|
["Landscape" pr-toggle-file-landscape-menu
|
|
:style toggle :selected pr-file-landscape
|
|
,@(funcall
|
|
pr-:help "Toggle landscape for PostScript file")
|
|
:active pr-ps-utility-alist]
|
|
["Duplex" pr-toggle-file-duplex-menu
|
|
:style toggle :selected pr-file-duplex
|
|
,@(funcall
|
|
pr-:help "Toggle duplex for PostScript file")
|
|
:active pr-ps-utility-alist]
|
|
["Tumble" pr-toggle-file-tumble-menu
|
|
:style toggle :selected pr-file-tumble
|
|
,@(funcall
|
|
pr-:help "Toggle tumble for PostScript file")
|
|
:active (and pr-file-duplex pr-ps-utility-alist)])
|
|
["Despool..." (call-interactively 'pr-despool-ps-print)
|
|
:active pr-spool-p :keys "\\[pr-despool-ps-print]"
|
|
,@(funcall
|
|
pr-:help "Despool PostScript buffer to printer or file (C-u)")])
|
|
["PostScript Printers" pr-update-menus
|
|
:active pr-ps-printer-alist :included (pr-visible-p 'postscript)
|
|
,@(funcall
|
|
pr-:help "Select PostScript printer")]
|
|
"--"
|
|
("Printify" :included (pr-visible-p 'text)
|
|
,@(funcall
|
|
pr-:help
|
|
"Replace non-printing chars with printable representations.")
|
|
["Directory" pr-printify-directory t]
|
|
["Buffer" pr-printify-buffer t]
|
|
["Region" pr-printify-region (ps-mark-active-p)])
|
|
("Print" :included (pr-visible-p 'text)
|
|
,@(funcall
|
|
pr-:help "Send text to printer")
|
|
["Directory" pr-txt-directory t]
|
|
["Buffer" pr-txt-buffer t]
|
|
["Region" pr-txt-region (ps-mark-active-p)]
|
|
["Mode" pr-txt-mode (pr-mode-alist-p)])
|
|
["Text Printers" pr-update-menus
|
|
:active pr-txt-printer-alist :included (pr-visible-p 'text)
|
|
,@(funcall
|
|
pr-:help "Select text printer")]
|
|
"--"
|
|
["Landscape" pr-toggle-landscape-menu
|
|
:style toggle :selected ps-landscape-mode
|
|
:included (pr-visible-p 'postscript-options)]
|
|
["Print Header" pr-toggle-header-menu
|
|
:style toggle :selected ps-print-header
|
|
:included (pr-visible-p 'postscript-options)]
|
|
["Print Header Frame" pr-toggle-header-frame-menu
|
|
:style toggle :selected ps-print-header-frame :active ps-print-header
|
|
:included (pr-visible-p 'postscript-options)]
|
|
["Line Number" pr-toggle-line-menu
|
|
:style toggle :selected ps-line-number
|
|
:included (pr-visible-p 'postscript-options)]
|
|
["Zebra Stripes" pr-toggle-zebra-menu
|
|
:style toggle :selected ps-zebra-stripes
|
|
:included (pr-visible-p 'postscript-options)]
|
|
["Duplex" pr-toggle-duplex-menu
|
|
:style toggle :selected ps-spool-duplex
|
|
:included (pr-visible-p 'postscript-options)]
|
|
["Tumble" pr-toggle-tumble-menu
|
|
:style toggle :selected ps-spool-tumble :active ps-spool-duplex
|
|
:included (pr-visible-p 'postscript-options)]
|
|
["Upside-Down" pr-toggle-upside-down-menu
|
|
:style toggle :selected ps-print-upside-down
|
|
:included (pr-visible-p 'postscript-options)]
|
|
("Print All Pages" :included (pr-visible-p 'postscript-options)
|
|
,@(funcall
|
|
pr-:help "Select odd/even pages/sheets to print")
|
|
["All Pages" (pr-even-or-odd-pages nil)
|
|
:style radio :selected (eq ps-even-or-odd-pages nil)]
|
|
["Even Pages" (pr-even-or-odd-pages 'even-page)
|
|
:style radio :selected (eq ps-even-or-odd-pages 'even-page)]
|
|
["Odd Pages" (pr-even-or-odd-pages 'odd-page)
|
|
:style radio :selected (eq ps-even-or-odd-pages 'odd-page)]
|
|
["Even Sheets" (pr-even-or-odd-pages 'even-sheet)
|
|
:style radio :selected (eq ps-even-or-odd-pages 'even-sheet)]
|
|
["Odd Sheets" (pr-even-or-odd-pages 'odd-sheet)
|
|
:style radio :selected (eq ps-even-or-odd-pages 'odd-sheet)])
|
|
"--"
|
|
["Spool Buffer" pr-toggle-spool-menu
|
|
:style toggle :selected pr-spool-p
|
|
:included (pr-visible-p 'postscript-process)
|
|
,@(funcall
|
|
pr-:help "Toggle PostScript spooling")]
|
|
["Print with faces" pr-toggle-faces-menu
|
|
:style toggle :selected pr-faces-p
|
|
:included (pr-visible-p 'postscript-process)
|
|
,@(funcall
|
|
pr-:help "Toggle PostScript printing with faces")]
|
|
["Print via Ghostscript" pr-toggle-ghostscript-menu
|
|
:style toggle :selected pr-print-using-ghostscript
|
|
:included (pr-visible-p 'postscript-process)
|
|
,@(funcall
|
|
pr-:help "Toggle PostScript generation using ghostscript")]
|
|
"--"
|
|
["Auto Region" pr-toggle-region-menu
|
|
:style toggle :selected pr-auto-region
|
|
:included (pr-visible-p 'printing)]
|
|
["Auto Mode" pr-toggle-mode-menu
|
|
:style toggle :selected pr-auto-mode
|
|
:included (pr-visible-p 'printing)]
|
|
["Menu Lock" pr-toggle-lock-menu
|
|
:style toggle :selected pr-menu-lock
|
|
:included (pr-visible-p 'printing)]
|
|
"--"
|
|
("Customize" :included (pr-visible-p 'help)
|
|
["printing" pr-customize t]
|
|
["ps-print" ps-print-customize t]
|
|
["lpr" lpr-customize t])
|
|
("Show Settings" :included (pr-visible-p 'help)
|
|
["printing" pr-show-pr-setup t]
|
|
["ps-print" pr-show-ps-setup t]
|
|
["lpr" pr-show-lpr-setup t])
|
|
["Help" pr-help :active t :included (pr-visible-p 'help)]
|
|
)))
|
|
|
|
|
|
(defvar pr-menu-print-item "print"
|
|
"Non-nil means that menu binding was not done.
|
|
|
|
Used by `pr-menu-bind' and `pr-update-menus'.")
|
|
|
|
|
|
(defun pr-menu-bind ()
|
|
"Install `printing' menu in the menubar.
|
|
|
|
On Emacs 20, it replaces the Tools/Print menu by Tools/Printing menu.
|
|
|
|
On Emacs 21 and 22, it replaces the File/Print* menu entries by File/Print
|
|
menu.
|
|
|
|
Calls `pr-update-menus' to adjust menus."
|
|
(interactive)
|
|
(cond
|
|
((featurep 'xemacs) ; XEmacs
|
|
;; Menu binding
|
|
(pr-xemacs-global-menubar
|
|
(pr-x-add-submenu nil (cons "Printing" pr-menu-spec) "Apps"))
|
|
(setq pr-menu-print-item nil))
|
|
|
|
|
|
(t ; GNU Emacs
|
|
;; Menu binding
|
|
(require 'easymenu)
|
|
;; Replace existing "print" item by "Printing" item.
|
|
;; If you're changing this file, you'll load it a second,
|
|
;; third... time, but "print" item exists only in the first load.
|
|
(cond
|
|
;; Emacs 20
|
|
((string< emacs-version "21.")
|
|
(easy-menu-change '("tools") "Printing" pr-menu-spec pr-menu-print-item)
|
|
(when pr-menu-print-item
|
|
(easy-menu-remove-item nil '("tools") pr-menu-print-item)
|
|
(setq pr-menu-print-item nil
|
|
pr-menu-bar (vector 'menu-bar 'tools
|
|
(pr-get-symbol "Printing")))))
|
|
;; Emacs 21 & 22
|
|
(t
|
|
(let* ((has-file (lookup-key global-map (vector 'menu-bar 'file)))
|
|
(item-file (if has-file '("file") '("files"))))
|
|
(cond
|
|
(pr-menu-print-item
|
|
(easy-menu-change item-file "Print" pr-menu-spec "print-buffer")
|
|
(let ((items '("print-buffer" "print-region"
|
|
"ps-print-buffer-faces" "ps-print-region-faces"
|
|
"ps-print-buffer" "ps-print-region")))
|
|
(while items
|
|
(easy-menu-remove-item nil item-file (car items))
|
|
(setq items (cdr items)))
|
|
(setq pr-menu-print-item nil
|
|
pr-menu-bar (vector 'menu-bar
|
|
(if has-file 'file 'files)
|
|
(pr-get-symbol "Print")))))
|
|
(t
|
|
(easy-menu-change item-file "Print" pr-menu-spec))))))))
|
|
(pr-update-menus t))
|
|
|
|
|
|
;; Key binding
|
|
(let ((pr-print-key (if (featurep 'xemacs)
|
|
'f22 ; XEmacs
|
|
'print))) ; GNU Emacs
|
|
(global-set-key `[,pr-print-key] 'pr-ps-fast-fire)
|
|
;; Well, M-print and S-print are used because in my keyboard S-print works
|
|
;; and M-print doesn't. But M-print can work in other keyboard.
|
|
(global-set-key `[(meta ,pr-print-key)] 'pr-ps-mode-using-ghostscript)
|
|
(global-set-key `[(shift ,pr-print-key)] 'pr-ps-mode-using-ghostscript)
|
|
;; Well, C-print and C-M-print are used because in my keyboard C-M-print works
|
|
;; and C-print doesn't. But C-print can work in other keyboard.
|
|
(global-set-key `[(control ,pr-print-key)] 'pr-txt-fast-fire)
|
|
(global-set-key `[(control meta ,pr-print-key)] 'pr-txt-fast-fire))
|
|
|
|
|
|
;;; You can also use something like:
|
|
;;;(global-set-key "\C-ci" 'pr-interface)
|
|
;;;(global-set-key "\C-cbp" 'pr-ps-buffer-print)
|
|
;;;(global-set-key "\C-cbx" 'pr-ps-buffer-preview)
|
|
;;;(global-set-key "\C-cbb" 'pr-ps-buffer-using-ghostscript)
|
|
;;;(global-set-key "\C-crp" 'pr-ps-region-print)
|
|
;;;(global-set-key "\C-crx" 'pr-ps-region-preview)
|
|
;;;(global-set-key "\C-crr" 'pr-ps-region-using-ghostscript)
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Help Message
|
|
|
|
|
|
(defconst pr-help-message
|
|
(concat "printing.el version " pr-version
|
|
" ps-print.el version " ps-print-version
|
|
"\n\n
|
|
Menu Layout
|
|
-----------
|
|
|
|
The `printing' menu (Tools/Printing or File/Print) has the following layout:
|
|
|
|
+-----------------------------+
|
|
A 0 | Printing Interface |
|
|
+-----------------------------+ +-A---------+ +-B------+
|
|
I 1 | PostScript Preview >|-------|Directory >|-----|1-up |
|
|
2 | PostScript Print >|---- A |Buffer >|-- B |2-up |
|
|
3 | PostScript Printer: name >|---- C |Region >|-- B |4-up |
|
|
+-----------------------------+ |Mode >|-- B |Other...|
|
|
II 4 | Printify >|-----\\ |File >|--\\ +--------+
|
|
5 | Print >|---\\ | |Despool... | |
|
|
6 | Text Printer: name >|-\\ | | +-----------+ |
|
|
+-----------------------------+ | | | +---------+ +------------+
|
|
III 7 |[ ]Landscape | | | \\-|Directory| | No Prep... | Ia
|
|
8 |[ ]Print Header | | | |Buffer | +------------+ Ib
|
|
9 |[ ]Print Header Frame | | | |Region | | name >|- C
|
|
10 |[ ]Line Number | | | +---------+ +------------+
|
|
11 |[ ]Zebra Stripes | | | +---------+ | 1-up... | Ic
|
|
12 |[ ]Duplex | | \\---|Directory| | 2-up... |
|
|
13 |[ ]Tumble | \\--\\ |Buffer | | 4-up... |
|
|
14 |[ ]Upside-Down | | |Region | | Other... |
|
|
15 | Print All Pages >|--\\ | |Mode | +------------+
|
|
+-----------------------------+ | | +---------+ |[ ]Landscape| Id
|
|
IV 16 |[ ]Spool Buffer | | | +-C-------+ |[ ]Duplex | Ie
|
|
17 |[ ]Print with faces | | \\--|( )name A| |[ ]Tumble | If
|
|
18 |[ ]Print via Ghostscript | | |( )name B| +------------+
|
|
+-----------------------------+ | |... |
|
|
V 19 |[ ]Auto Region | | |(*)name |
|
|
20 |[ ]Auto Mode | | |... |
|
|
21 |[ ]Menu Lock | | +---------+ +--------------+
|
|
+-----------------------------+ \\------------------|(*)All Pages |
|
|
VI 22 | Customize >|--- D +-D------+ |( )Even Pages |
|
|
23 | Show Settings >|-------|printing| |( )Odd Pages |
|
|
24 | Help | |ps-print| |( )Even Sheets|
|
|
+-----------------------------+ |lpr | |( )Odd Sheets |
|
|
+--------+ +--------------+
|
|
|
|
See `pr-visible-entry-list' for hiding some parts of the menu.
|
|
|
|
The menu has the following sections:
|
|
|
|
A. Interface:
|
|
|
|
0. You can use a buffer interface instead of menus. It looks like the
|
|
customization buffer. Basically, it has the same options found in the
|
|
menu and some extra options, all this on a buffer.
|
|
|
|
I. PostScript printing:
|
|
|
|
1. You can generate a PostScript file (if you type C-u before activating
|
|
menu) or PostScript temporary file for a directory, a buffer, a region
|
|
or a major mode, choosing 1-up, 2-up, 4-up or any other n-up printing;
|
|
after file generation, ghostview is activated using the file generated
|
|
as argument. This option is disabled if spooling is on (option 16).
|
|
Also, if you already have a PostScript file you can preview it.
|
|
Instead of previewing each buffer, region or major mode at once, you
|
|
can save temporarily the PostScript code generated in a buffer and
|
|
preview it later. The option `Despool...' despools the PostScript
|
|
spooling buffer in a temporary file and uses ghostview to preview it.
|
|
If you type C-u before choosing this option, the PostScript code
|
|
generated is saved in a file instead of saving in a temporary file. To
|
|
spool the PostScript code generated you need to turn on the option 16.
|
|
The option `Despool...' is enabled if spooling is on (option 16).
|
|
|
|
NOTE 1: It's possible to customize a major mode printing, just declare
|
|
the customization in `pr-mode-alist' and invoke some of
|
|
`*-mode*' commands or select Mode option in Printing menu. An
|
|
example for major mode usage is when you're using gnus (or mh,
|
|
or rmail, etc.) and you're in the *Summary* buffer, if you
|
|
forget to switch to the *Article* buffer before printing,
|
|
you'll get a nicely formatted list of article subjects shows
|
|
up at the printer. With major mode printing you don't need to
|
|
switch from gnus *Summary* buffer first.
|
|
|
|
NOTE 2: There are the following options for PostScript file processing:
|
|
Ia. Print the file *No Preprocessing*, that is, send it
|
|
directly to PostScript printer.
|
|
Ib. PostScript utility processing selection.
|
|
See `pr-ps-utility-alist' and `pr-setting-database' for
|
|
documentation.
|
|
Ic. Do n-up processing before printing.
|
|
Id. Toggle on/off landscape for PostScript file processing.
|
|
Ie. Toggle on/off duplex for PostScript file processing.
|
|
If. Toggle on/off tumble for PostScript file processing.
|
|
|
|
NOTE 3: Don't forget to download and install the utilities declared on
|
|
`pr-ps-utility-alist'.
|
|
|
|
2. Operate the same way as option 1, but it sends directly the PostScript
|
|
code (or put in a file, if you've typed C-u) or it uses ghostscript to
|
|
print the PostScript file generated. It depends on option 18, if it's
|
|
turned on, it uses ghostscript; otherwise, it sends directly to
|
|
printer. If spooling is on (option 16), the PostScript code is saved
|
|
temporarily in a buffer instead of printing it or saving it in a file.
|
|
Also, if you already have a PostScript file you can print it.
|
|
Instead of printing each buffer, region or major mode at once, you can
|
|
save temporarily the PostScript code generated in a buffer and print it
|
|
later. The option `Despool...' despools the PostScript spooling buffer
|
|
directly on a printer. If you type C-u before choosing this option,
|
|
the PostScript code generated is saved in a file instead of sending it to
|
|
the printer. To spool the PostScript code generated you need to turn on
|
|
option 16. This option is enabled if spooling is on (option 16).
|
|
See also the NOTE 1, NOTE 2 and NOTE 3 on option 1.
|
|
|
|
3. You can select a new PostScript printer to send PostScript code
|
|
generated. For selection it's used all PostScript printers defined
|
|
in `pr-ps-printer-alist' variable (see it for documentation).
|
|
See also `pr-setting-database'.
|
|
|
|
II. Text printing:
|
|
|
|
4. If you have control characters (character code from \\000 to \\037) in a
|
|
buffer and you want to print them in a text printer, select this
|
|
option. All control characters in your buffer or region will be
|
|
replaced by a printable representation. The printable representations
|
|
use ^ (for ASCII control characters) or hex. The characters tab,
|
|
linefeed, space, return and formfeed are not affected.
|
|
You don't need to select this option if you use any option of section
|
|
I, the PostScript engine treats control characters properly.
|
|
|
|
5. If you want to print a directory, buffer, region or major mode in a
|
|
text printer, select this option. See also the NOTE 1 on option 1.
|
|
|
|
6. You can select a new text printer to send text generated. For
|
|
selection it's used all text printers defined in `pr-txt-printer-alist'
|
|
variable (see it for documentation).
|
|
See also `pr-setting-database'.
|
|
|
|
III. PostScript page toggle options:
|
|
|
|
7. If you want a PostScript landscape printing, turn on this option.
|
|
|
|
8. If you want to have a header in each page in your PostScript code,
|
|
turn on this option.
|
|
|
|
9. If you want to draw a gaudy frame around the header, turn on this
|
|
option. This option is enabled if print header is on (option 8).
|
|
|
|
10. If you want that the line number is printed in your PostScript code,
|
|
turn on this option.
|
|
|
|
11. If you want background zebra stripes in your PostScript code, turn on
|
|
this option.
|
|
|
|
12. If you want a duplex printing and your PostScript printer has this
|
|
feature, turn on this option.
|
|
|
|
13. If you turned on duplex printing, you can choose if you want to have a
|
|
printing suitable for binding on the left or right (tumble off), or to
|
|
have a printing suitable for binding at top or bottom (tumble on).
|
|
This option is enabled if duplex is on (option 12).
|
|
|
|
14. If you want a PostScript upside-down printing, turn on this option.
|
|
|
|
15. With this option, you can choose if you want to print all pages, odd
|
|
pages, even pages, odd sheets or even sheets.
|
|
See also `ps-even-or-odd-pages'.
|
|
|
|
IV. PostScript processing toggle options:
|
|
|
|
16. If you want to spool the PostScript code generated, turn on this
|
|
option. To spool the PostScript code generated use option 2. You can
|
|
despool later by choosing option 1 or 2, sub-option `Despool...'.
|
|
|
|
17. If you use colors in your buffers and want to see these colors on your
|
|
PostScript code generated, turn on this option. If you have a
|
|
black/white PostScript printer, these colors are displayed in gray
|
|
scale by PostScript printer interpreter.
|
|
|
|
18. If you don't have a PostScript printer to send PostScript files, turn
|
|
on this option. When this option is on, the ghostscript is used to
|
|
print PostScript files. In GNU or Unix system, if ghostscript is set
|
|
as a PostScript filter, you don't need to turn on this option.
|
|
|
|
V. Printing customization:
|
|
|
|
19. If you want that region is automagically detected, turn on this
|
|
option. Note that this will only work if you're using transient mark
|
|
mode. When this option is on, the `*-buffer*' commands will behave
|
|
like `*-region*' commands, that is, `*-buffer*' commands will print
|
|
only the region marked instead of all buffer.
|
|
|
|
20. Turn this option on if you want that when current major-mode is
|
|
declared in `pr-mode-alist', the `*-buffer*' and `*-region*' commands
|
|
behave like `*-mode*' commands.
|
|
|
|
21. If you want that Printing menu stays open while you are setting
|
|
toggle options, turn on this option. The variables
|
|
`pr-menu-char-height' and `pr-menu-char-width' are used to guess the
|
|
menu position, so don't forget to adjust these variables if menu
|
|
position is not ok.
|
|
|
|
VI. Customization:
|
|
|
|
22. Besides all options in section III, IV and V, you can customize much
|
|
more PostScript options in `ps-print' option. Or you can customize
|
|
some `lpr' options for text printing. Or customize `printing'
|
|
options.
|
|
|
|
23. Show current settings for `printing', `ps-print' or `lpr'.
|
|
|
|
24. Quick help for printing menu layout.
|
|
")
|
|
"Printing help message.")
|
|
|
|
|
|
(defconst pr-interface-help-message
|
|
(concat "printing.el version " pr-version
|
|
" ps-print.el version " ps-print-version
|
|
"\n\n
|
|
The printing interface buffer has the same functionality as the printing menu.
|
|
The major difference is that the states (like sending PostScript generated to a
|
|
file, n-up printing, etc.) are set and saved between priting buffer
|
|
activation. Also, the landscape, duplex and tumble values are the same for
|
|
PostScript file and directory/buffer/region/mode processing; using menu, there
|
|
are different value sets for PostScript file and directory/buffer/region/mode
|
|
processing.
|
|
|
|
The printing interface buffer has the following sections:
|
|
|
|
1. Print:
|
|
|
|
Here you can choose to print/preview a buffer, a directory or a PostScript
|
|
file:
|
|
|
|
1a. Buffer:
|
|
|
|
* Buffer List:
|
|
Select a buffer from the current buffer list.
|
|
|
|
* Region:
|
|
If it's on, this means that the selected buffer has an active region,
|
|
so you can turn on/off, as you wish.
|
|
If it's off when a buffer is selected, this means that the selected
|
|
buffer has no active region, so it'll not be possible to turn it on.
|
|
If you want to process the region, let this option on.
|
|
If you want to process the whole buffer, let this option off.
|
|
|
|
* Mode:
|
|
If it's on, this means that the selected buffer major mode is declared
|
|
for major mode processing, so you can turn on/off, as you wish.
|
|
If it's off when a buffer is selected, this means that the selected
|
|
buffer major mode isn't declared for major mode processing, so it'll
|
|
not be possible to turn it on.
|
|
If you want the major mode processing, let this option on.
|
|
If you don't want the major mode processing, let this option off.
|
|
|
|
NOTE 1: It's possible to customize a major mode printing, just declare
|
|
the customization in `pr-mode-alist' and invoke some of
|
|
`*-mode*' commands or select Mode option in Printing menu. An
|
|
example for major mode usage is when you're using gnus (or mh,
|
|
or rmail, etc.) and you're in the *Summary* buffer, if you
|
|
forget to switch to the *Article* buffer before printing,
|
|
you'll get a nicely formatted list of article subjects shows
|
|
up at the printer. With major mode printing you don't need to
|
|
switch from gnus *Summary* buffer first.
|
|
|
|
1b. Directory:
|
|
|
|
* Directory:
|
|
Specify a valid directory path.
|
|
|
|
* File Regexp:
|
|
Specify a file name regexp. All file names in the directory that
|
|
match with regexp will be printed/previewed. An empty file name
|
|
regexp means to print/preview all files in the directory.
|
|
|
|
* List Directory Entry:
|
|
If it's turned on, list directory entries besides file entries.
|
|
|
|
1c. PostScript file:
|
|
|
|
* PostScript File:
|
|
Specify an existent PostScript file to print/preview.
|
|
|
|
* PostScript Utility:
|
|
Select a PostScript utility.
|
|
See `pr-ps-utility-alist' and `pr-setting-database' for documentation.
|
|
|
|
NOTE 2: Don't forget to download and install the utilities declared on
|
|
`pr-ps-utility-alist'.
|
|
|
|
* No Preprocessing:
|
|
If it's turned on, don't use the PostScript utility to preprocess the
|
|
PostScript file before printing/previewing.
|
|
|
|
2. PostScript printer:
|
|
|
|
* PostScript Printer:
|
|
You can select a new PostScript printer to send PostScript code
|
|
generated. For selection it's used all PostScript printers defined
|
|
in `pr-ps-printer-alist' variable (see it for documentation).
|
|
See also `pr-setting-database'.
|
|
|
|
* Despool:
|
|
If spooling is on, you can turn it on/off, as you wish.
|
|
If spooling is off, it'll not be possible to turn it on.
|
|
If it's turned on, specify to despools the PostScript spooling buffer in
|
|
a temporary file or in the selected PostScript file when
|
|
printing/previewing.
|
|
|
|
* Preview:
|
|
Preview the PostScript generated.
|
|
|
|
* Print:
|
|
Print the PostScript generated.
|
|
|
|
* Quit:
|
|
Quit from printing interface buffer.
|
|
|
|
* Send to Printer/Temporary File:
|
|
If it's turned on, the PostScript generated is sent directly to
|
|
PostScript printer or, for previewing, to a temporary file.
|
|
|
|
* Send to File:
|
|
Specify a file name to send the PostScript generated.
|
|
|
|
* N-Up:
|
|
Specify n-up printing.
|
|
|
|
3. Text printer:
|
|
|
|
* Text Printer:
|
|
Select a new text printer to send text generated. For selection it's used
|
|
all text printers defined in `pr-txt-printer-alist' variable (see it for
|
|
documentation). See also `pr-setting-database'.
|
|
|
|
* Printify:
|
|
If you have control characters (character code from \\000 to \\037) in a
|
|
buffer and you want to print them in a text printer, select this
|
|
option. All control characters in your buffer or region will be
|
|
replaced by a printable representation. The printable representations
|
|
use ^ (for ASCII control characters) or hex. The characters tab,
|
|
linefeed, space, return and formfeed are not affected.
|
|
You don't need to select this option if you use any option of section
|
|
I, the PostScript engine treats control characters properly.
|
|
|
|
* Print:
|
|
To print a directory, buffer, region or major mode in a
|
|
text printer, select this option. See also the NOTE 1 on section 1.
|
|
|
|
* Quit:
|
|
Quit from printing interface buffer.
|
|
|
|
4. Settings:
|
|
|
|
There are 3 setting columns:
|
|
|
|
4a. First column (left column):
|
|
|
|
* Landscape:
|
|
PostScript landscape printing.
|
|
|
|
* Print Header:
|
|
To have a header in each page in your PostScript code.
|
|
|
|
* Print Header Frame:
|
|
To draw a gaudy frame around the header.
|
|
|
|
* Line Number:
|
|
The line number is printed in your PostScript code.
|
|
|
|
* Zebra Stripes:
|
|
Background zebra stripes in your PostScript code.
|
|
|
|
* Duplex:
|
|
Duplex printing (if your PostScript printer has this feature).
|
|
|
|
* Tumble:
|
|
If duplex printing is on, you can choose if you want to have a
|
|
printing suitable for binding on the left or right (tumble off), or to
|
|
have a printing suitable for binding at top or bottom (tumble on).
|
|
|
|
* Upside-Down:
|
|
PostScript upside-down printing.
|
|
|
|
4b. Second column (middle column):
|
|
|
|
* Auto Region:
|
|
If you want that region is automagically detected, turn on this
|
|
option. Note that this will only work if you're using transient mark
|
|
mode. When this option is on, the `*-buffer*' commands will behave
|
|
like `*-region*' commands, that is, `*-buffer*' commands will print
|
|
only the region marked instead of all buffer.
|
|
|
|
* Auto Mode:
|
|
Turn this option on if you want that when current major-mode is
|
|
declared in `pr-mode-alist', the `*-buffer*' and `*-region*' commands
|
|
behave like `*-mode*' commands.
|
|
|
|
* Menu Lock:
|
|
If you want that Printing menu stays open while you are setting
|
|
toggle options, turn on this option. The variables
|
|
`pr-menu-char-height' and `pr-menu-char-width' are used to guess the
|
|
menu position, so don't forget to adjust these variables if menu
|
|
position is not ok.
|
|
|
|
* Spool Buffer:
|
|
To spool the PostScript code generated. You can despool later by
|
|
setting Despool option on PostScript printer section.
|
|
|
|
* Print with faces:
|
|
If you use colors in your buffers and want to see these colors on your
|
|
PostScript code generated, turn on this option. If you have a
|
|
black/white PostScript printer, these colors are displayed in gray
|
|
scale by PostScript printer interpreter.
|
|
|
|
* Print via Ghostscript:
|
|
If you don't have a PostScript printer to send PostScript files, turn
|
|
on this option. When this option is on, the ghostscript is used to
|
|
print PostScript files. In GNU or Unix system, if ghostscript is set
|
|
as a PostScript filter, you don't need to turn on this option.
|
|
|
|
* Parity Page Menu:
|
|
To print all pages, odd pages, even pages, odd sheets or even sheets.
|
|
See also `ps-even-or-odd-pages'.
|
|
|
|
4c. Third column (right column):
|
|
|
|
* Verbose:
|
|
That is, to be verbose when editing a field in interface buffer.
|
|
|
|
5. Customize:
|
|
|
|
Besides all options in section 4, you can customize much more PostScript
|
|
options in `ps-print' option. Or you can customize some `lpr' options for
|
|
text printing. Or customize `printing' options.
|
|
|
|
6. Show settings:
|
|
|
|
Show current settings for `printing', `ps-print' or `lpr'.
|
|
|
|
7. Help:
|
|
|
|
Quick help for printing interface buffer and printing menu layout. You can
|
|
also quit the printing interface buffer or kill all printing help buffer.
|
|
")
|
|
"Printing buffer interface help message.")
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Commands
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-interface (&optional buffer)
|
|
"Activate the printing interface buffer.
|
|
|
|
If BUFFER is nil, the current buffer is used for printing.
|
|
|
|
For more information, type \\[pr-interface-help]."
|
|
(interactive)
|
|
(save-excursion
|
|
(set-buffer (or buffer (current-buffer)))
|
|
(pr-create-interface)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-directory-preview (n-up dir file-regexp &optional filename)
|
|
"Preview directory using ghostview.
|
|
|
|
Interactively, the command prompts for N-UP printing number, a directory, a
|
|
file name regexp for matching and, when you use a prefix argument (C-u), the
|
|
command prompts the user for a file name, and saves the PostScript image in
|
|
that file instead of saving it in a temporary file.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. If DIR is
|
|
nil, prompts for DIRectory. If FILE-REGEXP is nil, prompts for
|
|
FILE(name)-REGEXP. The argument FILENAME is treated as follows: if it's nil,
|
|
save the image in a temporary file. If FILENAME is a string, save the
|
|
PostScript image in a file with that name. If FILENAME is t, prompts for a
|
|
file name.
|
|
|
|
See also documentation for `pr-list-directory'."
|
|
(interactive (pr-interactive-ps-dir-args (pr-prompt "PS preview dir")))
|
|
(pr-set-ps-dir-args 'n-up 'dir 'file-regexp 'filename
|
|
(pr-prompt "PS preview dir"))
|
|
(setq filename (pr-ps-file filename))
|
|
(pr-ps-file-list n-up dir file-regexp filename)
|
|
(or pr-spool-p
|
|
(pr-ps-file-preview filename)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-directory-using-ghostscript (n-up dir file-regexp &optional filename)
|
|
"Print directory using PostScript through ghostscript.
|
|
|
|
Interactively, the command prompts for N-UP printing number, a directory, a
|
|
file name regexp for matching and, when you use a prefix argument (C-u), the
|
|
command prompts the user for a file name, and saves the PostScript image in
|
|
that file instead of saving it in a temporary file.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. If DIR is
|
|
nil, prompts for DIRectory. If FILE-REGEXP is nil, prompts for
|
|
FILE(name)-REGEXP. The argument FILENAME is treated as follows: if it's nil,
|
|
save the image in a temporary file. If FILENAME is a string, save the
|
|
PostScript image in a file with that name. If FILENAME is t, prompts for a
|
|
file name.
|
|
|
|
See also documentation for `pr-list-directory'."
|
|
(interactive (pr-interactive-ps-dir-args (pr-prompt "PS print dir GS")))
|
|
(pr-set-ps-dir-args 'n-up 'dir 'file-regexp 'filename
|
|
(pr-prompt "PS print dir GS"))
|
|
(let ((file (pr-ps-file filename)))
|
|
(pr-ps-file-list n-up dir file-regexp file)
|
|
(pr-ps-file-using-ghostscript file)
|
|
(or filename (pr-delete-file file))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-directory-print (n-up dir file-regexp &optional filename)
|
|
"Print directory using PostScript printer.
|
|
|
|
Interactively, the command prompts for N-UP printing number, a directory, a
|
|
file name regexp for matching and, when you use a prefix argument (C-u), the
|
|
command prompts the user for a file name, and saves the PostScript image in
|
|
that file instead of saving it in a temporary file.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. If DIR is
|
|
nil, prompts for DIRectory. If FILE-REGEXP is nil, prompts for
|
|
FILE(name)-REGEXP. The argument FILENAME is treated as follows: if it's nil,
|
|
save the image in a temporary file. If FILENAME is a string, save the
|
|
PostScript image in a file with that name. If FILENAME is t, prompts for a
|
|
file name.
|
|
|
|
See also documentation for `pr-list-directory'."
|
|
(interactive (pr-interactive-ps-dir-args (pr-prompt "PS print dir")))
|
|
(pr-set-ps-dir-args 'n-up 'dir 'file-regexp 'filename
|
|
(pr-prompt "PS print dir"))
|
|
(let ((file (pr-ps-file filename)))
|
|
(pr-ps-file-list n-up dir file-regexp file)
|
|
(pr-ps-file-print file)
|
|
(or filename (pr-delete-file file))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-directory-ps-print (n-up dir file-regexp &optional filename)
|
|
"Print directory using PostScript printer or through ghostscript.
|
|
|
|
It depends on `pr-print-using-ghostscript'.
|
|
|
|
Interactively, the command prompts for N-UP printing number, a directory, a
|
|
file name regexp for matching and, when you use a prefix argument (C-u), the
|
|
command prompts the user for a file name, and saves the PostScript image in
|
|
that file instead of saving it in a temporary file.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. If DIR is
|
|
nil, prompts for DIRectory. If FILE-REGEXP is nil, prompts for
|
|
FILE(name)-REGEXP. The argument FILENAME is treated as follows: if it's nil,
|
|
save the image in a temporary file. If FILENAME is a string, save the
|
|
PostScript image in a file with that name. If FILENAME is t, prompts for a
|
|
file name.
|
|
|
|
See also documentation for `pr-list-directory'."
|
|
(interactive (pr-interactive-ps-dir-args
|
|
(pr-prompt (pr-prompt-gs "PS print dir"))))
|
|
(pr-set-ps-dir-args 'n-up 'dir 'file-regexp 'filename
|
|
(pr-prompt (pr-prompt-gs "PS print dir")))
|
|
(if (pr-using-ghostscript-p)
|
|
(pr-ps-directory-using-ghostscript n-up dir file-regexp filename)
|
|
(pr-ps-directory-print n-up dir file-regexp filename)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-buffer-preview (n-up &optional filename)
|
|
"Preview buffer using ghostview.
|
|
|
|
Interactively, the command prompts for N-UP printing number and, when you use a
|
|
prefix argument (C-u), the command prompts the user for a file name, and saves
|
|
the PostScript image in that file instead of saving it in a temporary file.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. The
|
|
argument FILENAME is treated as follows: if it's nil, save the image in a
|
|
temporary file. If FILENAME is a string, save the PostScript image in a file
|
|
with that name. If FILENAME is t, prompts for a file name."
|
|
(interactive (pr-interactive-n-up-file (pr-prompt "PS preview")))
|
|
(if (pr-auto-mode-p)
|
|
(pr-ps-mode-preview n-up filename)
|
|
(pr-ps-preview (pr-region-active-symbol) n-up filename
|
|
(pr-region-active-string "PS preview"))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-buffer-using-ghostscript (n-up &optional filename)
|
|
"Print buffer using PostScript through ghostscript.
|
|
|
|
Interactively, the command prompts for N-UP printing number and, when you use a
|
|
prefix argument (C-u), the command prompts the user for a file name, and saves
|
|
the PostScript image in that file instead of sending it to the printer.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. The
|
|
argument FILENAME is treated as follows: if it's nil, send the image to the
|
|
printer. If FILENAME is a string, save the PostScript image in a file with
|
|
that name. If FILENAME is t, prompts for a file name."
|
|
(interactive (pr-interactive-n-up-file (pr-prompt "PS print GS")))
|
|
(if (pr-auto-mode-p)
|
|
(pr-ps-mode-using-ghostscript n-up filename)
|
|
(pr-ps-using-ghostscript (pr-region-active-symbol) n-up filename
|
|
(pr-region-active-string "PS print GS"))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-buffer-print (n-up &optional filename)
|
|
"Print buffer using PostScript printer.
|
|
|
|
Interactively, the command prompts for N-UP printing number and, when you use a
|
|
prefix argument (C-u), the command prompts the user for a file name, and saves
|
|
the PostScript image in that file instead of sending it to the printer.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. The
|
|
argument FILENAME is treated as follows: if it's nil, send the image to the
|
|
printer. If FILENAME is a string, save the PostScript image in a file with
|
|
that name. If FILENAME is t, prompts for a file name."
|
|
(interactive (pr-interactive-n-up-file (pr-prompt "PS print")))
|
|
(if (pr-auto-mode-p)
|
|
(pr-ps-mode-print n-up filename)
|
|
(pr-ps-print (pr-region-active-symbol) n-up filename
|
|
(pr-region-active-string "PS print"))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-buffer-ps-print (n-up &optional filename)
|
|
"Print buffer using PostScript printer or through ghostscript.
|
|
|
|
It depends on `pr-print-using-ghostscript'.
|
|
|
|
Interactively, the command prompts for N-UP printing number and, when you use a
|
|
prefix argument (C-u), the command prompts the user for a file name, and saves
|
|
the PostScript image in that file instead of sending it to the printer.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. The
|
|
argument FILENAME is treated as follows: if it's nil, send the image to the
|
|
printer. If FILENAME is a string, save the PostScript image in a file with
|
|
that name. If FILENAME is t, prompts for a file name."
|
|
(interactive (pr-interactive-n-up-file
|
|
(pr-prompt (pr-prompt-gs "PS print"))))
|
|
(cond ((pr-auto-mode-p)
|
|
(pr-ps-mode-ps-print n-up filename))
|
|
((pr-using-ghostscript-p)
|
|
(pr-ps-using-ghostscript (pr-region-active-symbol) n-up filename
|
|
(pr-region-active-string "PS print GS")))
|
|
(t
|
|
(pr-ps-print (pr-region-active-symbol) n-up filename
|
|
(pr-region-active-string "PS print")))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-region-preview (n-up &optional filename)
|
|
"Preview region using ghostview.
|
|
|
|
See also `pr-ps-buffer-preview'."
|
|
(interactive (pr-interactive-n-up-file (pr-prompt-region "PS preview")))
|
|
(if (pr-auto-mode-p)
|
|
(let ((pr-auto-region t))
|
|
(pr-ps-mode-preview n-up filename))
|
|
(pr-ps-preview 'region n-up filename "PS preview region")))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-region-using-ghostscript (n-up &optional filename)
|
|
"Print region using PostScript through ghostscript.
|
|
|
|
See also `pr-ps-buffer-using-ghostscript'."
|
|
(interactive (pr-interactive-n-up-file (pr-prompt-region "PS print GS")))
|
|
(if (pr-auto-mode-p)
|
|
(let ((pr-auto-region t))
|
|
(pr-ps-mode-using-ghostscript n-up filename))
|
|
(pr-ps-using-ghostscript 'region n-up filename "PS print GS region")))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-region-print (n-up &optional filename)
|
|
"Print region using PostScript printer.
|
|
|
|
See also `pr-ps-buffer-print'."
|
|
(interactive (pr-interactive-n-up-file (pr-prompt-region "PS print")))
|
|
(if (pr-auto-mode-p)
|
|
(let ((pr-auto-region t))
|
|
(pr-ps-mode-print n-up filename))
|
|
(pr-ps-print 'region n-up filename "PS print region")))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-region-ps-print (n-up &optional filename)
|
|
"Print region using PostScript printer or through ghostscript.
|
|
|
|
See also `pr-ps-buffer-ps-print'."
|
|
(interactive (pr-interactive-n-up-file
|
|
(pr-prompt-region (pr-prompt-gs "PS print"))))
|
|
(cond ((pr-auto-mode-p)
|
|
(let ((pr-auto-region t))
|
|
(pr-ps-mode-ps-print n-up filename)))
|
|
((pr-using-ghostscript-p)
|
|
(pr-ps-using-ghostscript 'region n-up filename "PS print GS region"))
|
|
(t
|
|
(pr-ps-print 'region n-up filename "PS print region"))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-mode-preview (n-up &optional filename)
|
|
"Preview major mode using ghostview.
|
|
|
|
See also `pr-ps-buffer-preview'."
|
|
(interactive (pr-interactive-n-up-file "PS preview mode"))
|
|
(pr-set-n-up-and-filename 'n-up 'filename "PS preview mode")
|
|
(let ((file (pr-ps-file filename)))
|
|
(and (pr-ps-mode n-up file)
|
|
(not pr-spool-p)
|
|
(pr-ps-file-preview file))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-mode-using-ghostscript (n-up &optional filename)
|
|
"Print major mode using PostScript through ghostscript.
|
|
|
|
See also `pr-ps-buffer-using-ghostscript'."
|
|
(interactive (pr-interactive-n-up-file "PS print GS mode"))
|
|
(pr-set-n-up-and-filename 'n-up 'filename "PS print GS mode")
|
|
(let ((file (pr-ps-file filename)))
|
|
(when (and (pr-ps-mode n-up file)
|
|
(not pr-spool-p))
|
|
(pr-ps-file-using-ghostscript file)
|
|
(or filename (pr-delete-file file)))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-mode-print (n-up &optional filename)
|
|
"Print major mode using PostScript printer.
|
|
|
|
See also `pr-ps-buffer-print'."
|
|
(interactive (pr-interactive-n-up-file "PS print mode"))
|
|
(pr-set-n-up-and-filename 'n-up 'filename "PS print mode")
|
|
(pr-ps-mode n-up filename))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-mode-ps-print (n-up &optional filename)
|
|
"Print major mode using PostScript or through ghostscript.
|
|
|
|
See also `pr-ps-buffer-ps-print'."
|
|
(interactive (pr-interactive-n-up-file (pr-prompt-gs "PS print mode")))
|
|
(if (pr-using-ghostscript-p)
|
|
(pr-ps-mode-using-ghostscript n-up filename)
|
|
(pr-ps-mode-print n-up filename)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-printify-directory (&optional dir file-regexp)
|
|
"Replace nonprinting characters in directory with printable representations.
|
|
The printable representations use ^ (for ASCII control characters) or hex.
|
|
The characters tab, linefeed, space, return and formfeed are not affected.
|
|
|
|
Interactively, the command prompts for a directory and a file name regexp for
|
|
matching.
|
|
|
|
Noninteractively, if DIR is nil, prompts for DIRectory. If FILE-REGEXP is nil,
|
|
prompts for FILE(name)-REGEXP.
|
|
|
|
See also documentation for `pr-list-directory'."
|
|
(interactive (pr-interactive-dir-args "Printify dir"))
|
|
(pr-set-dir-args 'dir 'file-regexp "Printify dir")
|
|
(pr-file-list dir file-regexp 'pr-printify-buffer))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-printify-buffer ()
|
|
"Replace nonprinting characters in buffer with printable representations.
|
|
The printable representations use ^ (for ASCII control characters) or hex.
|
|
The characters tab, linefeed, space, return and formfeed are not affected."
|
|
(interactive "*")
|
|
(if (pr-region-active-p)
|
|
(pr-printify-region)
|
|
(printify-region (point-min) (point-max))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-printify-region ()
|
|
"Replace nonprinting characters in region with printable representations.
|
|
The printable representations use ^ (for ASCII control characters) or hex.
|
|
The characters tab, linefeed, space, return and formfeed are not affected."
|
|
(interactive "*")
|
|
(printify-region (point) (mark)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-txt-directory (&optional dir file-regexp)
|
|
"Print directory using text printer.
|
|
|
|
Interactively, the command prompts for a directory and a file name regexp for
|
|
matching.
|
|
|
|
Noninteractively, if DIR is nil, prompts for DIRectory. If FILE-REGEXP is nil,
|
|
prompts for FILE(name)-REGEXP.
|
|
|
|
See also documentation for `pr-list-directory'."
|
|
(interactive (pr-interactive-dir-args "Print dir"))
|
|
(pr-set-dir-args 'dir 'file-regexp "Print dir")
|
|
(pr-file-list dir file-regexp 'pr-txt-buffer))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-txt-buffer ()
|
|
"Print buffer using text printer."
|
|
(interactive)
|
|
(cond ((pr-auto-mode-p)
|
|
(pr-txt-mode))
|
|
((pr-region-active-p)
|
|
(pr-txt-region))
|
|
(t
|
|
(pr-txt-print (point-min) (point-max)))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-txt-region ()
|
|
"Print region using text printer."
|
|
(interactive)
|
|
(if (pr-auto-mode-p)
|
|
(let ((pr-auto-region t))
|
|
(pr-txt-mode))
|
|
(pr-txt-print (point) (mark))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-txt-mode ()
|
|
"Print major mode using text printer."
|
|
(interactive)
|
|
(let ((args (pr-mode-alist-p)))
|
|
(if args
|
|
(funcall (car args) (nthcdr 2 args))
|
|
(ding)
|
|
(message "`%s' major mode not declared." major-mode))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-despool-preview (&optional filename)
|
|
"Preview spooled PostScript.
|
|
|
|
Interactively, when you use a prefix argument (C-u), the command prompts the
|
|
user for a file name, and saves the spooled PostScript image in that file
|
|
instead of saving it in a temporary file.
|
|
|
|
Noninteractively, the argument FILENAME is treated as follows: if it is nil,
|
|
save the image in a temporary file. If FILENAME is a string, save the
|
|
PostScript image in a file with that name."
|
|
(interactive (list (ps-print-preprint current-prefix-arg)))
|
|
(let ((file (pr-ps-file filename)))
|
|
(when (stringp file)
|
|
(pr-despool-print file)
|
|
(pr-ps-file-preview file))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-despool-using-ghostscript (&optional filename)
|
|
"Print spooled PostScript using ghostscript.
|
|
|
|
Interactively, when you use a prefix argument (C-u), the command prompts the
|
|
user for a file name, and saves the spooled PostScript image in that file
|
|
instead of sending it to the printer.
|
|
|
|
Noninteractively, the argument FILENAME is treated as follows: if it is nil,
|
|
send the image to the printer. If FILENAME is a string, save the PostScript
|
|
image in a file with that name."
|
|
(interactive (list (ps-print-preprint current-prefix-arg)))
|
|
(let ((file (pr-ps-file filename)))
|
|
(when (stringp file)
|
|
(pr-despool-print file)
|
|
(pr-ps-file-using-ghostscript file)
|
|
(or filename (pr-delete-file file)))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-despool-print (&optional filename)
|
|
"Send the spooled PostScript to the printer.
|
|
|
|
Interactively, when you use a prefix argument (C-u), the command prompts the
|
|
user for a file name, and saves the spooled PostScript image in that file
|
|
instead of sending it to the printer.
|
|
|
|
Noninteractively, the argument FILENAME is treated as follows: if it is nil,
|
|
send the image to the printer. If FILENAME is a string, save the PostScript
|
|
image in a file with that name."
|
|
(interactive (list (ps-print-preprint current-prefix-arg)))
|
|
(pr-save-file-modes
|
|
(let ((ps-lpr-command (pr-command pr-ps-command))
|
|
(ps-lpr-switches pr-ps-switches)
|
|
(ps-printer-name-option pr-ps-printer-switch)
|
|
(ps-printer-name pr-ps-printer))
|
|
(ps-despool filename))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-despool-ps-print (&optional filename)
|
|
"Send the spooled PostScript to the printer or use ghostscript to print it.
|
|
|
|
Interactively, when you use a prefix argument (C-u), the command prompts the
|
|
user for a file name, and saves the spooled PostScript image in that file
|
|
instead of sending it to the printer.
|
|
|
|
Noninteractively, the argument FILENAME is treated as follows: if it is nil,
|
|
send the image to the printer. If FILENAME is a string, save the PostScript
|
|
image in a file with that name."
|
|
(interactive (list (ps-print-preprint current-prefix-arg)))
|
|
(if pr-print-using-ghostscript
|
|
(pr-despool-using-ghostscript filename)
|
|
(pr-despool-print filename)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-file-preview (filename)
|
|
"Preview PostScript file FILENAME."
|
|
(interactive (list (pr-ps-infile-preprint "Preview ")))
|
|
(and (stringp filename) (file-exists-p filename)
|
|
(pr-call-process pr-gv-command filename)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-file-up-preview (n-up ifilename &optional ofilename)
|
|
"Preview PostScript file FILENAME."
|
|
(interactive (pr-interactive-n-up-inout "PS preview"))
|
|
(let ((outfile (pr-ps-utility-args 'n-up 'ifilename 'ofilename
|
|
"PS preview ")))
|
|
(pr-ps-utility-process n-up ifilename outfile)
|
|
(pr-ps-file-preview outfile)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-file-using-ghostscript (filename)
|
|
"Print PostScript file FILENAME using ghostscript."
|
|
(interactive (list (pr-ps-infile-preprint "Print preview ")))
|
|
(and (stringp filename) (file-exists-p filename)
|
|
(let* ((file (pr-expand-file-name filename))
|
|
(tempfile (pr-dosify-file-name (make-temp-file file))))
|
|
;; gs use
|
|
(pr-call-process pr-gs-command
|
|
(format "-sDEVICE=%s" pr-gs-device)
|
|
(format "-r%d" pr-gs-resolution)
|
|
(pr-switches-string pr-gs-switches "pr-gs-switches")
|
|
(format "-sOutputFile=\"%s\"" tempfile)
|
|
file
|
|
"-c quit")
|
|
;; printing
|
|
(pr-ps-file-print tempfile)
|
|
;; deleting
|
|
(pr-delete-file tempfile))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-file-print (filename)
|
|
"Print PostScript file FILENAME."
|
|
(interactive (list (pr-ps-infile-preprint "Print ")))
|
|
(and (stringp filename) (file-exists-p filename)
|
|
;; printing
|
|
(let ((file (pr-expand-file-name filename)))
|
|
(if (string= pr-ps-command "")
|
|
;; default action
|
|
(let ((ps-spool-buffer (get-buffer-create ps-spool-buffer-name)))
|
|
(save-excursion
|
|
(set-buffer ps-spool-buffer)
|
|
(erase-buffer)
|
|
(insert-file-contents-literally file))
|
|
(pr-despool-print))
|
|
;; use `pr-ps-command' to print
|
|
(apply 'pr-call-process
|
|
pr-ps-command
|
|
(pr-switches-string pr-ps-switches "pr-ps-switches")
|
|
(if (string-match "cp" pr-ps-command)
|
|
;; for "cp" (cmd in out)
|
|
(list file
|
|
(concat pr-ps-printer-switch pr-ps-printer))
|
|
;; else, for others (cmd out in)
|
|
(list (concat pr-ps-printer-switch pr-ps-printer)
|
|
file)))))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-file-ps-print (filename)
|
|
"Send PostScript file FILENAME to printer or use ghostscript to print it."
|
|
(interactive (list (pr-ps-infile-preprint
|
|
(if pr-print-using-ghostscript
|
|
"Print preview "
|
|
"Print "))))
|
|
(if pr-print-using-ghostscript
|
|
(pr-ps-file-using-ghostscript filename)
|
|
(pr-ps-file-print filename)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-file-up-ps-print (n-up ifilename &optional ofilename)
|
|
"Process a PostScript file IFILENAME and send it to printer.
|
|
|
|
Interactively, the command prompts for N-UP printing number, for an input
|
|
PostScript file IFILENAME and, when you use a prefix argument (C-u), the
|
|
command prompts the user for an output PostScript file name OFILENAME, and
|
|
saves the PostScript image in that file instead of sending it to the printer.
|
|
|
|
Noninteractively, if N-UP is nil, prompts for N-UP printing number. The
|
|
argument IFILENAME is treated as follows: if it's t, prompts for an input
|
|
PostScript file name; otherwise, it *must* be a string that it's an input
|
|
PostScript file name. The argument OFILENAME is treated as follows: if it's
|
|
nil, send the image to the printer. If OFILENAME is a string, save the
|
|
PostScript image in a file with that name. If OFILENAME is t, prompts for a
|
|
file name."
|
|
(interactive (pr-interactive-n-up-inout
|
|
(if pr-print-using-ghostscript
|
|
"PS print GS"
|
|
"PS print")))
|
|
(let ((outfile (pr-ps-utility-args 'n-up 'ifilename 'ofilename
|
|
(if pr-print-using-ghostscript
|
|
"PS print GS "
|
|
"PS print "))))
|
|
(pr-ps-utility-process n-up ifilename outfile)
|
|
(unless ofilename
|
|
(pr-ps-file-ps-print outfile)
|
|
(pr-delete-file outfile))))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-file-duplex ()
|
|
"Toggle duplex for PostScript file."
|
|
(interactive)
|
|
(pr-toggle-file-duplex-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-file-tumble ()
|
|
"Toggle tumble for PostScript file.
|
|
|
|
If tumble is off, produces a printing suitable for binding on the left or
|
|
right.
|
|
If tumble is on, produces a printing suitable for binding at the top or
|
|
bottom."
|
|
(interactive)
|
|
(pr-toggle-file-tumble-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-file-landscape ()
|
|
"Toggle landscape for PostScript file."
|
|
(interactive)
|
|
(pr-toggle-file-landscape-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-ghostscript ()
|
|
"Toggle printing using ghostscript."
|
|
(interactive)
|
|
(pr-toggle-ghostscript-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-faces ()
|
|
"Toggle printing with faces."
|
|
(interactive)
|
|
(pr-toggle-faces-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-spool ()
|
|
"Toggle spooling."
|
|
(interactive)
|
|
(pr-toggle-spool-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-duplex ()
|
|
"Toggle duplex."
|
|
(interactive)
|
|
(pr-toggle-duplex-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-tumble ()
|
|
"Toggle tumble.
|
|
|
|
If tumble is off, produces a printing suitable for binding on the left or
|
|
right.
|
|
If tumble is on, produces a printing suitable for binding at the top or
|
|
bottom."
|
|
(interactive)
|
|
(pr-toggle-tumble-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-landscape ()
|
|
"Toggle landscape."
|
|
(interactive)
|
|
(pr-toggle-landscape-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-upside-down ()
|
|
"Toggle upside-down."
|
|
(interactive)
|
|
(pr-toggle-upside-down-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-line ()
|
|
"Toggle line number."
|
|
(interactive)
|
|
(pr-toggle-line-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-zebra ()
|
|
"Toggle zebra stripes."
|
|
(interactive)
|
|
(pr-toggle-zebra-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-header ()
|
|
"Toggle printing header."
|
|
(interactive)
|
|
(pr-toggle-header-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-header-frame ()
|
|
"Toggle printing header frame."
|
|
(interactive)
|
|
(pr-toggle-header-frame-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-lock ()
|
|
"Toggle menu lock."
|
|
(interactive)
|
|
(pr-toggle-lock-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-region ()
|
|
"Toggle auto region."
|
|
(interactive)
|
|
(pr-toggle-region-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-toggle-mode ()
|
|
"Toggle auto mode."
|
|
(interactive)
|
|
(pr-toggle-mode-menu t))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-customize (&rest ignore)
|
|
"Customization of the `printing' group."
|
|
(interactive)
|
|
(customize-group 'printing))
|
|
|
|
|
|
;;;###autoload
|
|
(defun lpr-customize (&rest ignore)
|
|
"Customization of the `lpr' group."
|
|
(interactive)
|
|
(customize-group 'lpr))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-help (&rest ignore)
|
|
"Help for the printing package."
|
|
(interactive)
|
|
(pr-show-setup pr-help-message "*Printing Help*"))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-name ()
|
|
"Interactively select a PostScript printer."
|
|
(interactive)
|
|
(pr-menu-set-ps-title
|
|
(pr-complete-alist "PostScript printer"
|
|
pr-ps-printer-alist pr-ps-name)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-txt-name ()
|
|
"Interactively select a text printer."
|
|
(interactive)
|
|
(pr-menu-set-txt-title
|
|
(pr-complete-alist "Text printer"
|
|
pr-txt-printer-alist pr-txt-name)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-utility ()
|
|
"Interactively select a PostScript utility."
|
|
(interactive)
|
|
(pr-menu-set-utility-title
|
|
(pr-complete-alist "Postscript utility"
|
|
pr-ps-utility-alist pr-ps-utility)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-show-ps-setup (&rest ignore)
|
|
"Show current ps-print settings."
|
|
(interactive)
|
|
(pr-show-setup (ps-setup) "*PS Setup*"))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-show-pr-setup (&rest ignore)
|
|
"Show current printing settings."
|
|
(interactive)
|
|
(pr-show-setup (pr-setup) "*PR Setup*"))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-show-lpr-setup (&rest ignore)
|
|
"Show current lpr settings."
|
|
(interactive)
|
|
(pr-show-setup (lpr-setup) "*LPR Setup*"))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Fast Commands
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-ps-fast-fire (n-up &optional select)
|
|
"Fast fire function for PostScript printing.
|
|
|
|
If a region is active, the region will be printed instead of the whole buffer.
|
|
Also if the current major-mode is defined in `pr-mode-alist', the settings in
|
|
`pr-mode-alist' will be used, that is, the current buffer or region will be
|
|
printed using `pr-ps-mode-ps-print'.
|
|
|
|
|
|
Interactively, you have the following situations:
|
|
|
|
M-x pr-ps-fast-fire RET
|
|
The command prompts the user for a N-UP value and printing will
|
|
immediatelly be done using the current active printer.
|
|
|
|
C-u M-x pr-ps-fast-fire RET
|
|
C-u 0 M-x pr-ps-fast-fire RET
|
|
The command prompts the user for a N-UP value and also for a current
|
|
PostScript printer, then printing will immediatelly be done using the new
|
|
current active printer.
|
|
|
|
C-u 1 M-x pr-ps-fast-fire RET
|
|
The command prompts the user for a N-UP value and also for a file name,
|
|
and saves the PostScript image in that file instead of sending it to the
|
|
printer.
|
|
|
|
C-u 2 M-x pr-ps-fast-fire RET
|
|
The command prompts the user for a N-UP value, then for a current
|
|
PostScript printer and, finally, for a file name. Then change the active
|
|
printer to that choosen by user and saves the PostScript image in
|
|
that file instead of sending it to the printer.
|
|
|
|
|
|
Noninteractively, the argument N-UP should be a positive integer greater than
|
|
zero and the argument SELECT is treated as follows:
|
|
|
|
If it's nil, send the image to the printer.
|
|
|
|
If it's a list or an integer lesser or equal to zero, the command prompts
|
|
the user for a current PostScript printer, then printing will immediatelly
|
|
be done using the new current active printer.
|
|
|
|
If it's an integer equal to 1, the command prompts the user for a file name
|
|
and saves the PostScript image in that file instead of sending it to the
|
|
printer.
|
|
|
|
If it's an integer greater or equal to 2, the command prompts the user for a
|
|
current PostScript printer and for a file name. Then change the active
|
|
printer to that choosen by user and saves the PostScript image in that file
|
|
instead of sending it to the printer.
|
|
|
|
If it's a symbol which it's defined in `pr-ps-printer-alist', it's the new
|
|
active printer and printing will immediatelly be done using the new active
|
|
printer.
|
|
|
|
Otherwise, send the image to the printer.
|
|
|
|
|
|
Note that this command always behaves as if `pr-auto-region' and `pr-auto-mode'
|
|
are both set to t."
|
|
(interactive (list (pr-interactive-n-up (pr-prompt-gs "PS print fast"))
|
|
current-prefix-arg))
|
|
(let ((pr-auto-region t)
|
|
(pr-auto-mode t)
|
|
filename)
|
|
(cond ((null select))
|
|
((listp select)
|
|
(pr-ps-name))
|
|
((and (symbolp select)
|
|
(assq select pr-ps-printer-alist))
|
|
(pr-menu-set-ps-title select))
|
|
((integerp select)
|
|
(and (/= select 1)
|
|
(pr-ps-name))
|
|
(and (>= select 1) (not pr-spool-p)
|
|
(setq filename (pr-ps-outfile-preprint
|
|
(if pr-print-using-ghostscript
|
|
"Fast GS "
|
|
"Fast "))))))
|
|
(pr-ps-buffer-ps-print
|
|
(if (integerp n-up)
|
|
(min (max n-up 1) 100)
|
|
(error "n-up must be an integer greater than zero"))
|
|
filename)))
|
|
|
|
|
|
;;;###autoload
|
|
(defun pr-txt-fast-fire (&optional select-printer)
|
|
"Fast fire function for text printing.
|
|
|
|
If a region is active, the region will be printed instead of the whole buffer.
|
|
Also if the current major-mode is defined in `pr-mode-alist', the settings in
|
|
`pr-mode-alist' will be used, that is, the current buffer or region will be
|
|
printed using `pr-txt-mode'.
|
|
|
|
Interactively, when you use a prefix argument (C-u), the command prompts the
|
|
user for a new active text printer.
|
|
|
|
Noninteractively, the argument SELECT-PRINTER is treated as follows:
|
|
|
|
If it's nil, the printing is sent to the current active text printer.
|
|
|
|
If it's a symbol which it's defined in `pr-txt-printer-alist', it's the new
|
|
active printer and printing will immediatelly be done using the new active
|
|
printer.
|
|
|
|
If it's non-nil, the command prompts the user for a new active text printer.
|
|
|
|
Note that this command always behaves as if `pr-auto-region' and `pr-auto-mode'
|
|
are both set to t."
|
|
(interactive (list current-prefix-arg))
|
|
(cond ((null select-printer))
|
|
((and (symbolp select-printer)
|
|
(assq select-printer pr-txt-printer-alist))
|
|
(pr-menu-set-txt-title select-printer))
|
|
(t
|
|
(pr-txt-name)))
|
|
(let ((pr-auto-region t)
|
|
(pr-auto-mode t))
|
|
(pr-txt-buffer)))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Utilities
|
|
|
|
|
|
(defun pr-setup ()
|
|
"Return the current `printing' setup.
|
|
|
|
This is *not* an interactive command.
|
|
One way to see `printing' setup is to switch to a *Scratch* buffer and type:
|
|
|
|
M-: (insert (pr-setup)) RET
|
|
|
|
Or choose the menu option Printing/Show Settings/printing."
|
|
(let (ps-prefix-quote)
|
|
(mapconcat
|
|
#'ps-print-quote
|
|
(list
|
|
(concat "\n;;; printing.el version " pr-version "\n")
|
|
";; internal vars"
|
|
(ps-comment-string "emacs-version " emacs-version)
|
|
(ps-comment-string "pr-txt-command " pr-txt-command)
|
|
(ps-comment-string "pr-txt-switches "
|
|
(pr-switches-string pr-txt-switches "pr-txt-switches"))
|
|
(ps-comment-string "pr-txt-printer " pr-txt-printer)
|
|
(ps-comment-string "pr-ps-command " pr-ps-command)
|
|
(ps-comment-string "pr-ps-switches "
|
|
(pr-switches-string pr-ps-switches "pr-ps-switches"))
|
|
(ps-comment-string "pr-ps-printer-switch" pr-ps-printer-switch)
|
|
(ps-comment-string "pr-ps-printer " pr-ps-printer)
|
|
(ps-comment-string "pr-cygwin-system " pr-cygwin-system)
|
|
(ps-comment-string "ps-windows-system " ps-windows-system)
|
|
(ps-comment-string "ps-lp-system " ps-lp-system)
|
|
nil
|
|
'(14 . pr-path-style)
|
|
'(14 . pr-path-alist)
|
|
nil
|
|
'(21 . pr-txt-name)
|
|
'(21 . pr-txt-printer-alist)
|
|
nil
|
|
'(20 . pr-ps-name)
|
|
'(20 . pr-ps-printer-alist)
|
|
nil
|
|
'(20 . pr-temp-dir)
|
|
'(20 . pr-ps-temp-file)
|
|
'(20 . pr-file-modes)
|
|
'(20 . pr-delete-temp-file)
|
|
'(20 . pr-list-directory)
|
|
nil
|
|
'(17 . pr-gv-command)
|
|
'(17 . pr-gs-command)
|
|
'(17 . pr-gs-switches)
|
|
'(17 . pr-gs-device)
|
|
'(17 . pr-gs-resolution)
|
|
nil
|
|
'(27 . pr-print-using-ghostscript)
|
|
'(27 . pr-faces-p)
|
|
'(27 . pr-spool-p)
|
|
'(27 . pr-file-landscape)
|
|
'(27 . pr-file-duplex)
|
|
'(27 . pr-file-tumble)
|
|
'(27 . pr-auto-region)
|
|
'(27 . pr-auto-mode)
|
|
nil
|
|
'(20 . pr-ps-utility)
|
|
'(20 . pr-ps-utility-alist)
|
|
nil
|
|
'(14 . pr-mode-alist)
|
|
nil
|
|
'(20 . pr-menu-lock)
|
|
'(20 . pr-menu-char-height)
|
|
'(20 . pr-menu-char-width)
|
|
nil
|
|
'(20 . pr-setting-database)
|
|
nil
|
|
'(22 . pr-visible-entry-list)
|
|
nil
|
|
'(22 . pr-buffer-verbose)
|
|
'(22 . pr-buffer-name)
|
|
'(22 . pr-buffer-name-ignore)
|
|
")\n\n;;; printing.el - end of settings\n")
|
|
"\n")))
|
|
|
|
|
|
(defun lpr-setup ()
|
|
"Return the current `lpr' setup.
|
|
|
|
This is *not* an interactive command.
|
|
One way to see `lpr' setup is to switch to a *Scratch* buffer and type:
|
|
|
|
M-: (insert (lpr-setup)) RET
|
|
|
|
Or choose the menu option Printing/Show Settings/lpr."
|
|
(let (ps-prefix-quote)
|
|
(mapconcat
|
|
#'ps-print-quote
|
|
(list
|
|
"\n;;; lpr.el settings\n"
|
|
(ps-comment-string "emacs-version" emacs-version)
|
|
nil
|
|
'(25 . printer-name)
|
|
'(25 . lpr-switches)
|
|
'(25 . lpr-add-switches)
|
|
'(25 . lpr-command)
|
|
'(25 . lpr-headers-switches)
|
|
'(25 . print-region-function)
|
|
'(25 . lpr-page-header-program)
|
|
'(25 . lpr-page-header-switches)
|
|
")\n\n;;; lpr.el - end of settings\n")
|
|
"\n")))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-e (adapted from mh-e-init.el -- Tom Vogels <tov@ece.cmu.edu>)
|
|
|
|
|
|
(defalias 'pr-mh-get-msg-num 'mh-get-msg-num)
|
|
(defalias 'pr-mh-show 'mh-show)
|
|
(defalias 'pr-mh-start-of-uncleaned-message 'mh-start-of-uncleaned-message)
|
|
(defvar mh-show-buffer nil)
|
|
|
|
|
|
(defun pr-article-date ()
|
|
"Find the date of an article or mail message in current buffer.
|
|
Return only the dayname, if present, weekday, month, and year."
|
|
(save-excursion
|
|
(goto-char (point-min))
|
|
(if (re-search-forward
|
|
"^Date:[ \t]+\\(\\([A-Za-z]+, \\)?[0-9]+ [A-Za-z]+ [0-9]+\\)" nil t)
|
|
(buffer-substring (match-beginning 1) (match-end 1))
|
|
(format-time-string "%Y/%m/%d"))))
|
|
|
|
|
|
(defun pr-mh-current-message ()
|
|
"Go to mh-inbox current message."
|
|
(let ((msg (or (pr-mh-get-msg-num nil) 0)))
|
|
(pr-mh-show)
|
|
(set-buffer mh-show-buffer)
|
|
(goto-char (point-min))
|
|
(pr-mh-start-of-uncleaned-message)
|
|
(message "Printing message %d" msg)))
|
|
|
|
|
|
(defun pr-mh-print-1 (n-up filename header-list)
|
|
"Print mh-inbox current message in PostScript."
|
|
(save-excursion
|
|
(save-window-excursion
|
|
(pr-mh-current-message)
|
|
(pr-mode-print n-up filename header-list (point)))))
|
|
|
|
|
|
(defun pr-mh-lpr-1 (header-list)
|
|
"Print mh-inbox current message in text printer."
|
|
(save-excursion
|
|
(save-window-excursion
|
|
(pr-mh-current-message)
|
|
(pr-mode-lpr header-list (point)))))
|
|
|
|
|
|
(defalias 'pr-mh-print-2 'pr-mode-print)
|
|
|
|
|
|
(defalias 'pr-mh-lpr-2 'pr-mode-lpr)
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rmail (hacked from ps-print.el)
|
|
|
|
|
|
(defun pr-rmail-lpr (header-list)
|
|
"Print RMAIL current message in text printer."
|
|
(pr-lpr-message-from-summary header-list
|
|
'rmail-buffer 'rmail-summary-buffer))
|
|
|
|
|
|
(defun pr-rmail-print (n-up filename header-list)
|
|
"Print RMAIL current message in PostScript."
|
|
(pr-ps-message-from-summary n-up filename header-list
|
|
'rmail-buffer 'rmail-summary-buffer))
|
|
|
|
|
|
(defun pr-ps-message-from-summary (n-up filename header-list
|
|
summary-buffer summary-default)
|
|
"Print current message in PostScript."
|
|
(let ((buf (or (and (boundp summary-buffer)
|
|
(symbol-value summary-buffer))
|
|
(symbol-value summary-default))))
|
|
(and (get-buffer buf)
|
|
(save-excursion
|
|
(set-buffer buf)
|
|
(pr-mode-print n-up filename header-list)))))
|
|
|
|
|
|
(defun pr-lpr-message-from-summary (header-list summary-buffer summary-default)
|
|
"Print current message in text printer."
|
|
(let ((buf (or (and (boundp summary-buffer)
|
|
(symbol-value summary-buffer))
|
|
(symbol-value summary-default))))
|
|
(and (get-buffer buf)
|
|
(save-excursion
|
|
(set-buffer buf)
|
|
(pr-mode-lpr header-list)))))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gnus (hacked from ps-print.el)
|
|
|
|
|
|
(defvar pr-gnus-article "*Article*")
|
|
|
|
|
|
(defun pr-gnus-print (n-up filename header-list)
|
|
"Print *Article* current message in PostScript."
|
|
(pr-ps-message-from-summary n-up filename header-list
|
|
'gnus-article-buffer 'pr-gnus-article))
|
|
|
|
|
|
(defun pr-gnus-lpr (header-list)
|
|
"Print *Article* current message in text printer."
|
|
(pr-lpr-message-from-summary header-list
|
|
'gnus-article-buffer 'pr-gnus-article))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vm (hacked from ps-print.el)
|
|
|
|
|
|
(defvar pr-vm-summary "")
|
|
|
|
|
|
(defun pr-vm-print (n-up filename header-list)
|
|
"Print current vm message in PostScript."
|
|
(pr-ps-message-from-summary n-up filename header-list
|
|
'vm-mail-buffer 'pr-vm-summary))
|
|
|
|
|
|
(defun pr-vm-lpr (header-list)
|
|
"Print current vm message in text printer."
|
|
(pr-lpr-message-from-summary header-list
|
|
'vm-mail-buffer 'pr-vm-summary))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Mode Functions
|
|
|
|
|
|
(defun pr-ps-mode (n-up filename)
|
|
"If current major mode is declared, print it in PostScript."
|
|
(let ((args (pr-mode-alist-p)))
|
|
(if args
|
|
(let ((fun (cdr args)))
|
|
(funcall (car fun) n-up filename (cdr fun))
|
|
t)
|
|
(ding)
|
|
(message "`%s' major mode not declared." major-mode)
|
|
nil)))
|
|
|
|
|
|
(defmacro pr-local-variable (header-list &rest body)
|
|
`(save-excursion
|
|
(let ((ps-header-lines (or (nth 0 ,header-list) ps-header-lines))
|
|
(ps-left-header (or (nth 1 ,header-list) ps-left-header))
|
|
(ps-right-header (or (nth 2 ,header-list) ps-right-header))
|
|
ps-razzle-dazzle)
|
|
(let ((local-var-list (pr-eval-local-alist (nthcdr 4 ,header-list))))
|
|
,@body
|
|
(and (nth 3 ,header-list)
|
|
(pr-kill-local-variable local-var-list))))))
|
|
|
|
|
|
(defun pr-mode-print (n-up filename header-list &optional from to)
|
|
"Print current major mode in PostScript."
|
|
(pr-local-variable
|
|
header-list
|
|
(let ((file (pr-ps-file filename))
|
|
(start (cond (from)
|
|
((pr-region-active-p) (region-beginning))
|
|
(t nil)
|
|
)))
|
|
(pr-text2ps (pr-region-active-symbol start) n-up file start
|
|
(cond (to)
|
|
((pr-region-active-p) (region-end))
|
|
(from (point-max))
|
|
))
|
|
(unless (or pr-spool-p filename)
|
|
(pr-ps-file-print file)
|
|
(pr-delete-file file)))))
|
|
|
|
|
|
(defun pr-mode-lpr (header-list &optional from to)
|
|
"Print current major mode in text printer."
|
|
(pr-local-variable
|
|
header-list
|
|
(pr-txt-print (cond (from)
|
|
((pr-region-active-p) (region-beginning))
|
|
(t (point-min)))
|
|
(cond (to)
|
|
((pr-region-active-p) (region-end))
|
|
(t (point-max))))))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Menu Lock
|
|
|
|
|
|
(defconst pr-menu-entry-alist
|
|
'((postscript . 3)
|
|
(text . 3)
|
|
(postscript-options . 9)
|
|
(postscript-process . 3)
|
|
(printing . 3)
|
|
(help . 3)
|
|
)
|
|
"Alist that associates menu part with number of items per part.
|
|
|
|
It's used by `pr-menu-index'.
|
|
|
|
Each element has the form:
|
|
|
|
(MENU-PART . NUMBER-OF-ITEMS)
|
|
|
|
See `pr-visible-entry-alist'.")
|
|
|
|
|
|
(defun pr-menu-index (entry index)
|
|
(let ((base-list
|
|
(cond ((eq entry 'text)
|
|
'(postscript))
|
|
((eq entry 'postscript-options)
|
|
'(postscript text))
|
|
((eq entry 'postscript-process)
|
|
'(postscript text postscript-options))
|
|
((eq entry 'printing)
|
|
'(postscript text postscript-options postscript-process))
|
|
(t
|
|
nil)
|
|
))
|
|
key)
|
|
(while base-list
|
|
(setq key (car base-list)
|
|
base-list (cdr base-list))
|
|
(and (pr-visible-p key)
|
|
(setq index (+ index
|
|
(cdr (assq key pr-menu-entry-alist)))))))
|
|
(+ index 2))
|
|
|
|
|
|
(defvar pr-menu-position nil)
|
|
(defvar pr-menu-state nil)
|
|
|
|
|
|
(cond
|
|
((featurep 'xemacs)
|
|
;; XEmacs
|
|
(defvar current-mouse-event nil) ; to avoid compilation gripes
|
|
(defun pr-menu-position (entry index horizontal)
|
|
(pr-x-make-event
|
|
'button-release
|
|
(list 'button 1
|
|
'x (- (pr-x-event-x-pixel current-mouse-event) ; X
|
|
(* horizontal pr-menu-char-width))
|
|
'y (- (pr-x-event-y-pixel current-mouse-event) ; Y
|
|
(* (pr-menu-index entry index) pr-menu-char-height)))))
|
|
)
|
|
(ps-windows-system
|
|
;; GNU Emacs for Windows 9x/NT
|
|
(defun pr-menu-position (entry index horizontal)
|
|
(let ((pos (cdr (pr-e-mouse-pixel-position))))
|
|
(list
|
|
(list (or (car pos) 0) ; X
|
|
(- (or (cdr pos) 0) ; Y
|
|
(* (pr-menu-index entry index) pr-menu-char-height)))
|
|
(selected-frame)))) ; frame
|
|
)
|
|
(t
|
|
;; GNU Emacs
|
|
(defun pr-menu-position (entry index horizontal)
|
|
(let ((pos (cdr (pr-e-mouse-pixel-position))))
|
|
(list
|
|
(list (- (or (car pos) 0) ; X
|
|
(* horizontal pr-menu-char-width))
|
|
(- (or (cdr pos) 0) ; Y
|
|
(* (pr-menu-index entry index) pr-menu-char-height)))
|
|
(selected-frame)))) ; frame
|
|
))
|
|
|
|
(cond
|
|
((featurep 'xemacs)
|
|
;; XEmacs
|
|
(defvar current-menubar nil) ; to avoid compilation gripes
|
|
(defun pr-menu-lookup (path)
|
|
(car (pr-x-find-menu-item current-menubar (cons "Printing" path))))
|
|
|
|
;; XEmacs
|
|
(defun pr-menu-lock (entry index horizontal state path)
|
|
(when pr-menu-lock
|
|
(or (and pr-menu-position (eq state pr-menu-state))
|
|
(setq pr-menu-position (pr-menu-position entry index horizontal)
|
|
pr-menu-state state))
|
|
(let* ((menu (pr-menu-lookup path))
|
|
(result (pr-x-get-popup-menu-response menu pr-menu-position)))
|
|
(and (pr-x-misc-user-event-p result)
|
|
(funcall (pr-x-event-function result)
|
|
(pr-x-event-object result))))
|
|
(setq pr-menu-position nil))))
|
|
|
|
|
|
(t
|
|
;; GNU Emacs
|
|
(defun pr-menu-lookup (path)
|
|
(lookup-key global-map
|
|
(if path
|
|
(vconcat pr-menu-bar
|
|
(mapcar 'pr-get-symbol
|
|
(if (listp path)
|
|
path
|
|
(list path))))
|
|
pr-menu-bar)))
|
|
|
|
;; GNU Emacs
|
|
(defun pr-menu-lock (entry index horizontal state path)
|
|
(when pr-menu-lock
|
|
(or (and pr-menu-position (eq state pr-menu-state))
|
|
(setq pr-menu-position (pr-menu-position entry index horizontal)
|
|
pr-menu-state state))
|
|
(let* ((menu (pr-menu-lookup path))
|
|
(result (x-popup-menu pr-menu-position menu)))
|
|
(and result
|
|
(let ((command (lookup-key menu (vconcat result))))
|
|
(if (fboundp command)
|
|
(funcall command)
|
|
(eval command)))))
|
|
(setq pr-menu-position nil)))))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Printer & Utility Selection
|
|
|
|
|
|
(defun pr-update-var (var-sym alist)
|
|
(or (assq (symbol-value var-sym) alist)
|
|
(set var-sym (car (car alist)))))
|
|
|
|
|
|
(defun pr-update-menus (&optional force)
|
|
"Update utility, PostScript and text printer menus.
|
|
|
|
If FORCE is non-nil, update menus doesn't matter if `pr-ps-printer-alist',
|
|
`pr-txt-printer-alist' or `pr-ps-utility-alist' were modified or not;
|
|
otherwise, update PostScript printer menu iff `pr-ps-printer-menu-modified' is
|
|
non-nil, update text printer menu iff `pr-txt-printer-menu-modified' is
|
|
non-nil, and update PostScript File menus iff `pr-ps-utility-menu-modified' is
|
|
non-nil.
|
|
|
|
If menu binding was not done, calls `pr-menu-bind'."
|
|
(interactive "P")
|
|
(if pr-menu-print-item ; since v6.8.4
|
|
;; There was no menu binding yet, so do it now!
|
|
;; This is a hack to be compatible with old versions of printing.
|
|
;; So, user does not need to change printing calling in init files.
|
|
(pr-menu-bind)
|
|
;; Here menu binding is ok.
|
|
(pr-update-var 'pr-ps-name pr-ps-printer-alist)
|
|
(pr-update-var 'pr-txt-name pr-txt-printer-alist)
|
|
(pr-update-var 'pr-ps-utility pr-ps-utility-alist)
|
|
(pr-do-update-menus force)))
|
|
|
|
|
|
(defvar pr-ps-printer-menu-modified t
|
|
"Non-nil means `pr-ps-printer-alist' was modified and we need to update menu.")
|
|
(defvar pr-txt-printer-menu-modified t
|
|
"Non-nil means `pr-txt-printer-alist' was modified and we need to update menu.")
|
|
(defvar pr-ps-utility-menu-modified t
|
|
"Non-nil means `pr-ps-utility-alist' was modified and we need to update menu.")
|
|
|
|
|
|
(defconst pr-even-or-odd-alist
|
|
'((nil . "Print All Pages")
|
|
(even-page . "Print Even Pages")
|
|
(odd-page . "Print Odd Pages")
|
|
(even-sheet . "Print Even Sheets")
|
|
(odd-sheet . "Print Odd Sheets")))
|
|
|
|
|
|
(defun pr-menu-create (name alist var-sym fun entry index)
|
|
(cons name
|
|
(mapcar
|
|
#'(lambda (elt)
|
|
(let ((sym (car elt)))
|
|
(vector
|
|
(symbol-name sym)
|
|
(list fun (list 'quote sym) nil (list 'quote entry) index)
|
|
:style 'radio
|
|
:selected (list 'eq var-sym (list 'quote sym)))))
|
|
alist)))
|
|
|
|
|
|
(cond
|
|
((featurep 'xemacs)
|
|
;; XEmacs
|
|
(defalias 'pr-update-mode-line 'set-menubar-dirty-flag)
|
|
|
|
;; XEmacs
|
|
(defvar pr-ps-name-old "PostScript Printers")
|
|
(defvar pr-txt-name-old "Text Printers")
|
|
(defvar pr-ps-utility-old "PostScript Utility")
|
|
(defvar pr-even-or-odd-old "Print All Pages")
|
|
|
|
;; XEmacs
|
|
(defun pr-do-update-menus (&optional force)
|
|
(pr-menu-alist pr-ps-printer-alist
|
|
'pr-ps-name
|
|
'pr-menu-set-ps-title
|
|
'("Printing")
|
|
'pr-ps-printer-menu-modified
|
|
force
|
|
pr-ps-name-old
|
|
'postscript 2)
|
|
(pr-menu-alist pr-txt-printer-alist
|
|
'pr-txt-name
|
|
'pr-menu-set-txt-title
|
|
'("Printing")
|
|
'pr-txt-printer-menu-modified
|
|
force
|
|
pr-txt-name-old
|
|
'text 2)
|
|
(let ((save-var pr-ps-utility-menu-modified))
|
|
(pr-menu-alist pr-ps-utility-alist
|
|
'pr-ps-utility
|
|
'pr-menu-set-utility-title
|
|
'("Printing" "PostScript Print" "File")
|
|
'save-var
|
|
force
|
|
pr-ps-utility-old
|
|
nil 1))
|
|
(pr-menu-alist pr-ps-utility-alist
|
|
'pr-ps-utility
|
|
'pr-menu-set-utility-title
|
|
'("Printing" "PostScript Preview" "File")
|
|
'pr-ps-utility-menu-modified
|
|
force
|
|
pr-ps-utility-old
|
|
nil 1)
|
|
(pr-even-or-odd-pages ps-even-or-odd-pages force))
|
|
|
|
;; XEmacs
|
|
(defun pr-menu-alist (alist var-sym fun menu-path modified-sym force name
|
|
entry index)
|
|
(when (and alist (or force (symbol-value modified-sym)))
|
|
(pr-xemacs-global-menubar
|
|
(pr-x-add-submenu menu-path
|
|
(pr-menu-create name alist var-sym
|
|
fun entry index)))
|
|
(funcall fun (symbol-value var-sym))
|
|
(set modified-sym nil)))
|
|
|
|
;; XEmacs
|
|
(defun pr-relabel-menu-item (newname var-sym)
|
|
(pr-xemacs-global-menubar
|
|
(pr-x-relabel-menu-item
|
|
(list "Printing" (symbol-value var-sym))
|
|
newname)
|
|
(set var-sym newname)))
|
|
|
|
;; XEmacs
|
|
(defun pr-menu-set-ps-title (value &optional item entry index)
|
|
(pr-relabel-menu-item (format "PostScript Printer: %s" value)
|
|
'pr-ps-name-old)
|
|
(pr-ps-set-printer value)
|
|
(and index
|
|
(pr-menu-lock entry index 12 'toggle nil)))
|
|
|
|
;; XEmacs
|
|
(defun pr-menu-set-txt-title (value &optional item entry index)
|
|
(pr-relabel-menu-item (format "Text Printer: %s" value)
|
|
'pr-txt-name-old)
|
|
(pr-txt-set-printer value)
|
|
(and index
|
|
(pr-menu-lock entry index 12 'toggle nil)))
|
|
|
|
;; XEmacs
|
|
(defun pr-menu-set-utility-title (value &optional item entry index)
|
|
(pr-xemacs-global-menubar
|
|
(let ((newname (format "%s" value)))
|
|
(pr-x-relabel-menu-item
|
|
(list "Printing" "PostScript Print" "File" pr-ps-utility-old)
|
|
newname)
|
|
(pr-x-relabel-menu-item
|
|
(list "Printing" "PostScript Preview" "File" pr-ps-utility-old)
|
|
newname)
|
|
(setq pr-ps-utility-old newname)))
|
|
(pr-ps-set-utility value)
|
|
(and index
|
|
(pr-menu-lock entry index 5 nil '("PostScript Print" "File"))))
|
|
|
|
;; XEmacs
|
|
(defun pr-even-or-odd-pages (value &optional no-lock)
|
|
(pr-relabel-menu-item (cdr (assq value pr-even-or-odd-alist))
|
|
'pr-even-or-odd-old)
|
|
(setq ps-even-or-odd-pages value)
|
|
(or no-lock
|
|
(pr-menu-lock 'postscript-options 8 12 'toggle nil))))
|
|
|
|
|
|
(t
|
|
;; GNU Emacs
|
|
(defalias 'pr-update-mode-line 'force-mode-line-update)
|
|
|
|
;; GNU Emacs
|
|
(defun pr-do-update-menus (&optional force)
|
|
(pr-menu-alist pr-ps-printer-alist
|
|
'pr-ps-name
|
|
'pr-menu-set-ps-title
|
|
"PostScript Printers"
|
|
'pr-ps-printer-menu-modified
|
|
force
|
|
"PostScript Printers"
|
|
'postscript 2)
|
|
(pr-menu-alist pr-txt-printer-alist
|
|
'pr-txt-name
|
|
'pr-menu-set-txt-title
|
|
"Text Printers"
|
|
'pr-txt-printer-menu-modified
|
|
force
|
|
"Text Printers"
|
|
'text 2)
|
|
(let ((save-var pr-ps-utility-menu-modified))
|
|
(pr-menu-alist pr-ps-utility-alist
|
|
'pr-ps-utility
|
|
'pr-menu-set-utility-title
|
|
'("PostScript Print" "File" "PostScript Utility")
|
|
'save-var
|
|
force
|
|
"PostScript Utility"
|
|
nil 1))
|
|
(pr-menu-alist pr-ps-utility-alist
|
|
'pr-ps-utility
|
|
'pr-menu-set-utility-title
|
|
'("PostScript Preview" "File" "PostScript Utility")
|
|
'pr-ps-utility-menu-modified
|
|
force
|
|
"PostScript Utility"
|
|
nil 1)
|
|
(pr-even-or-odd-pages ps-even-or-odd-pages force))
|
|
|
|
;; GNU Emacs
|
|
(defun pr-menu-get-item (name-list)
|
|
;; NAME-LIST is a string or a list of strings.
|
|
(or (listp name-list)
|
|
(setq name-list (list name-list)))
|
|
(and name-list
|
|
(let* ((reversed (reverse name-list))
|
|
(name (pr-get-symbol (car reversed)))
|
|
(path (nreverse (cdr reversed)))
|
|
(menu (lookup-key
|
|
global-map
|
|
(vconcat pr-menu-bar
|
|
(mapcar 'pr-get-symbol path)))))
|
|
(assq name (nthcdr 2 menu)))))
|
|
|
|
;; GNU Emacs
|
|
(defvar pr-temp-menu nil)
|
|
|
|
;; GNU Emacs
|
|
(defun pr-menu-alist (alist var-sym fun menu-path modified-sym force name
|
|
entry index)
|
|
(when (and alist (or force (symbol-value modified-sym)))
|
|
(easy-menu-define pr-temp-menu nil ""
|
|
(pr-menu-create name alist var-sym fun entry index))
|
|
(let ((item (pr-menu-get-item menu-path)))
|
|
(and item
|
|
(let* ((binding (nthcdr 3 item))
|
|
(key-binding (cdr binding)))
|
|
(setcar binding pr-temp-menu)
|
|
(and key-binding (listp (car key-binding))
|
|
(setcdr binding (cdr key-binding))) ; skip KEY-BINDING
|
|
(funcall fun (symbol-value var-sym) item))))
|
|
(set modified-sym nil)))
|
|
|
|
;; GNU Emacs
|
|
(defun pr-menu-set-item-name (item name)
|
|
(and item
|
|
(setcar (nthcdr 2 item) name))) ; ITEM-NAME
|
|
|
|
;; GNU Emacs
|
|
(defun pr-menu-set-ps-title (value &optional item entry index)
|
|
(pr-menu-set-item-name (or item
|
|
(pr-menu-get-item "PostScript Printers"))
|
|
(format "PostScript Printer: %s" value))
|
|
(pr-ps-set-printer value)
|
|
(and index
|
|
(pr-menu-lock entry index 12 'toggle nil)))
|
|
|
|
;; GNU Emacs
|
|
(defun pr-menu-set-txt-title (value &optional item entry index)
|
|
(pr-menu-set-item-name (or item
|
|
(pr-menu-get-item "Text Printers"))
|
|
(format "Text Printer: %s" value))
|
|
(pr-txt-set-printer value)
|
|
(and index
|
|
(pr-menu-lock entry index 12 'toggle nil)))
|
|
|
|
;; GNU Emacs
|
|
(defun pr-menu-set-utility-title (value &optional item entry index)
|
|
(let ((name (symbol-name value)))
|
|
(if item
|
|
(pr-menu-set-item-name item name)
|
|
(pr-menu-set-item-name
|
|
(pr-menu-get-item
|
|
'("PostScript Print" "File" "PostScript Utility"))
|
|
name)
|
|
(pr-menu-set-item-name
|
|
(pr-menu-get-item
|
|
'("PostScript Preview" "File" "PostScript Utility"))
|
|
name)))
|
|
(pr-ps-set-utility value)
|
|
(and index
|
|
(pr-menu-lock entry index 5 nil '("PostScript Print" "File"))))
|
|
|
|
;; GNU Emacs
|
|
(defun pr-even-or-odd-pages (value &optional no-lock)
|
|
(pr-menu-set-item-name (pr-menu-get-item "Print All Pages")
|
|
(cdr (assq value pr-even-or-odd-alist)))
|
|
(setq ps-even-or-odd-pages value)
|
|
(or no-lock
|
|
(pr-menu-lock 'postscript-options 8 12 'toggle nil)))))
|
|
|
|
|
|
(defun pr-ps-set-utility (value)
|
|
(let ((item (cdr (assq value pr-ps-utility-alist))))
|
|
(or item
|
|
(error
|
|
"Invalid PostScript utility name `%s' for variable `pr-ps-utility'"
|
|
value))
|
|
(setq pr-ps-utility value)
|
|
(pr-eval-alist (nthcdr 9 item)))
|
|
(pr-update-mode-line))
|
|
|
|
|
|
(defun pr-ps-set-printer (value)
|
|
(let ((ps (cdr (assq value pr-ps-printer-alist))))
|
|
(or ps
|
|
(error
|
|
"Invalid PostScript printer name `%s' for variable `pr-ps-name'"
|
|
value))
|
|
(setq pr-ps-name value
|
|
pr-ps-command (pr-dosify-file-name (nth 0 ps))
|
|
pr-ps-switches (nth 1 ps)
|
|
pr-ps-printer-switch (nth 2 ps)
|
|
pr-ps-printer (nth 3 ps))
|
|
(or (stringp pr-ps-command)
|
|
(setq pr-ps-command
|
|
(cond (ps-windows-system "print")
|
|
(ps-lp-system "lp")
|
|
(t "lpr")
|
|
)))
|
|
(or (stringp pr-ps-printer-switch)
|
|
(setq pr-ps-printer-switch
|
|
(cond (ps-windows-system "/D:")
|
|
(ps-lp-system "-d")
|
|
(t "-P")
|
|
)))
|
|
(pr-eval-alist (nthcdr 4 ps)))
|
|
(pr-update-mode-line))
|
|
|
|
|
|
(defun pr-txt-set-printer (value)
|
|
(let ((txt (cdr (assq value pr-txt-printer-alist))))
|
|
(or txt
|
|
(error "Invalid text printer name `%s' for variable `pr-txt-name'"
|
|
value))
|
|
(setq pr-txt-name value
|
|
pr-txt-command (pr-dosify-file-name (nth 0 txt))
|
|
pr-txt-switches (nth 1 txt)
|
|
pr-txt-printer (nth 2 txt)))
|
|
(or (stringp pr-txt-command)
|
|
(setq pr-txt-command
|
|
(cond (ps-windows-system "print")
|
|
(ps-lp-system "lp")
|
|
(t "lpr")
|
|
)))
|
|
(pr-update-mode-line))
|
|
|
|
|
|
(defun pr-eval-alist (alist)
|
|
(mapcar #'(lambda (option)
|
|
(let ((var-sym (car option))
|
|
(value (cdr option)))
|
|
(if (eq var-sym 'inherits-from:)
|
|
(pr-eval-setting-alist value 'global)
|
|
(set var-sym (eval value)))))
|
|
alist))
|
|
|
|
|
|
(defun pr-eval-local-alist (alist)
|
|
(let (local-list)
|
|
(mapcar #'(lambda (option)
|
|
(let ((var-sym (car option))
|
|
(value (cdr option)))
|
|
(setq local-list
|
|
(if (eq var-sym 'inherits-from:)
|
|
(nconc (pr-eval-setting-alist value) local-list)
|
|
(set (make-local-variable var-sym) (eval value))
|
|
(cons var-sym local-list)))))
|
|
alist)
|
|
local-list))
|
|
|
|
|
|
(defun pr-eval-setting-alist (key &optional global old)
|
|
(let ((setting (cdr (assq key pr-setting-database))))
|
|
(and setting
|
|
(let ((inherits (nth 0 setting))
|
|
(local (nth 1 setting))
|
|
(kill (nth 2 setting))
|
|
local-list)
|
|
(and local global
|
|
(progn
|
|
(ding)
|
|
(message "There are local buffer settings for `%S'." key)
|
|
(setq global nil)))
|
|
(and inherits
|
|
(if (memq inherits old)
|
|
(error "Circular inheritance for `%S'" inherits)
|
|
(setq local-list
|
|
(pr-eval-setting-alist inherits global
|
|
(cons inherits old)))))
|
|
(mapcar
|
|
(cond ((not local) ; global settings
|
|
#'(lambda (option)
|
|
(let ((var-sym (car option)))
|
|
(or (eq var-sym 'inherits-from:)
|
|
(set var-sym (eval (cdr option)))))))
|
|
(kill ; local settings with killing
|
|
#'(lambda (option)
|
|
(let ((var-sym (car option)))
|
|
(unless (eq var-sym 'inherits-from:)
|
|
(setq local-list (cons var-sym local-list))
|
|
(set (make-local-variable var-sym)
|
|
(eval (cdr option)))))))
|
|
(t ; local settings without killing
|
|
#'(lambda (option)
|
|
(let ((var-sym (car option)))
|
|
(or (eq var-sym 'inherits-from:)
|
|
(set (make-local-variable var-sym)
|
|
(eval (cdr option))))))))
|
|
(nthcdr 3 setting))
|
|
local-list))))
|
|
|
|
|
|
(defun pr-kill-local-variable (local-var-list)
|
|
(mapcar 'kill-local-variable local-var-list))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Internal Functions (II)
|
|
|
|
|
|
(defun pr-toggle (var-sym mess entry index horizontal state
|
|
&optional path no-menu)
|
|
(set var-sym (not (symbol-value var-sym)))
|
|
(message "%s is %s" mess (if (symbol-value var-sym) "on" "off"))
|
|
(or no-menu
|
|
(pr-menu-lock entry index horizontal state path)))
|
|
|
|
|
|
(defun pr-toggle-file-duplex-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-file-duplex "PS file duplex" nil 7 5 nil
|
|
'("PostScript Print" "File") no-menu))
|
|
|
|
|
|
(defun pr-toggle-file-tumble-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-file-tumble "PS file tumble" nil 8 5 nil
|
|
'("PostScript Print" "File") no-menu))
|
|
|
|
|
|
(defun pr-toggle-file-landscape-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-file-landscape "PS file landscape" nil 6 5 nil
|
|
'("PostScript Print" "File") no-menu))
|
|
|
|
|
|
(defun pr-toggle-ghostscript-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-print-using-ghostscript "Printing using ghostscript"
|
|
'postscript-process 2 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-faces-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-faces-p "Printing with faces"
|
|
'postscript-process 1 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-spool-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-spool-p "Spooling printing"
|
|
'postscript-process 0 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-duplex-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'ps-spool-duplex "Printing duplex"
|
|
'postscript-options 5 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-tumble-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'ps-spool-tumble "Tumble"
|
|
'postscript-options 6 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-landscape-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'ps-landscape-mode "Landscape"
|
|
'postscript-options 0 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-upside-down-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'ps-print-upside-down "Upside-Down"
|
|
'postscript-options 7 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-line-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'ps-line-number "Line number"
|
|
'postscript-options 3 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-zebra-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'ps-zebra-stripes "Zebra stripe"
|
|
'postscript-options 4 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-header-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'ps-print-header "Print header"
|
|
'postscript-options 1 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-header-frame-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'ps-print-header-frame "Print header frame"
|
|
'postscript-options 2 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-lock-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-menu-lock "Menu lock"
|
|
'printing 2 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-region-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-auto-region "Auto region"
|
|
'printing 0 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-toggle-mode-menu (&optional no-menu)
|
|
(interactive)
|
|
(pr-toggle 'pr-auto-mode "Auto mode"
|
|
'printing 1 12 'toggle nil no-menu))
|
|
|
|
|
|
(defun pr-prompt (str)
|
|
(if (pr-auto-mode-p)
|
|
(concat str " mode")
|
|
(pr-region-active-string str)))
|
|
|
|
|
|
(defun pr-prompt-region (str)
|
|
(concat str (if (pr-auto-mode-p)
|
|
" mode"
|
|
" region")))
|
|
|
|
|
|
(defun pr-prompt-gs (str)
|
|
(if (pr-using-ghostscript-p)
|
|
(concat str " GS")
|
|
str))
|
|
|
|
|
|
(defun pr-region-active-symbol (&optional region-p)
|
|
(if (or region-p (pr-region-active-p))
|
|
'region
|
|
'buffer))
|
|
|
|
|
|
(defun pr-region-active-string (prefix)
|
|
(concat prefix
|
|
(if (pr-region-active-p)
|
|
" region"
|
|
" buffer")))
|
|
|
|
|
|
(defun pr-show-setup (settings buffer-name)
|
|
(with-output-to-temp-buffer buffer-name
|
|
(princ settings)
|
|
(print-help-return-message)))
|
|
|
|
|
|
(defun pr-complete-alist (prompt alist default)
|
|
(let ((collection (mapcar #'(lambda (elt)
|
|
(setq elt (car elt))
|
|
(cons (symbol-name elt) elt))
|
|
alist)))
|
|
(cdr (assoc (completing-read (concat prompt ": ")
|
|
collection nil t
|
|
(symbol-name default) nil
|
|
(symbol-name default))
|
|
collection))))
|
|
|
|
|
|
(defun pr-delete-file (file)
|
|
(and pr-delete-temp-file (file-exists-p file)
|
|
(delete-file file)))
|
|
|
|
|
|
(defun pr-expand-file-name (filename)
|
|
(pr-dosify-file-name (expand-file-name filename)))
|
|
|
|
|
|
(defun pr-ps-outfile-preprint (&optional mess)
|
|
(let* ((prompt (format "%soutput PostScript file name: " (or mess "")))
|
|
(res (read-file-name prompt default-directory "" nil)))
|
|
(while (cond ((not (file-writable-p res))
|
|
(ding)
|
|
(setq prompt "is unwritable"))
|
|
((file-directory-p res)
|
|
(ding)
|
|
(setq prompt "is a directory"))
|
|
((file-exists-p res)
|
|
(ding)
|
|
(setq prompt "exists")
|
|
(not (y-or-n-p (format "File `%s' exists; overwrite? "
|
|
res))))
|
|
(t nil))
|
|
(setq res (read-file-name
|
|
(format "File %s; PostScript file: " prompt)
|
|
(file-name-directory res) nil nil
|
|
(file-name-nondirectory res))))
|
|
(pr-expand-file-name res)))
|
|
|
|
|
|
(defun pr-ps-infile-preprint (&optional mess)
|
|
(let* ((prompt (format "%sinput PostScript file name: " (or mess "")))
|
|
(res (read-file-name prompt default-directory "" nil)))
|
|
(while (cond ((not (file-exists-p res))
|
|
(ding)
|
|
(setq prompt "doesn't exist"))
|
|
((not (file-readable-p res))
|
|
(ding)
|
|
(setq prompt "is unreadable"))
|
|
((file-directory-p res)
|
|
(ding)
|
|
(setq prompt "is a directory"))
|
|
(t nil))
|
|
(setq res (read-file-name
|
|
(format "File %s; PostScript file: " prompt)
|
|
(file-name-directory res) nil nil
|
|
(file-name-nondirectory res))))
|
|
(pr-expand-file-name res)))
|
|
|
|
|
|
(defun pr-ps-utility-args (n-up-sym infile-sym outfile-sym prompt)
|
|
;; check arguments for PostScript file processing.
|
|
;; n-up
|
|
(or (symbol-value n-up-sym)
|
|
(set n-up-sym (pr-interactive-n-up prompt)))
|
|
;; input file
|
|
(and (eq (symbol-value infile-sym) t)
|
|
(set infile-sym (pr-ps-infile-preprint prompt)))
|
|
(or (symbol-value infile-sym)
|
|
(error "%s: input PostScript file name is missing" prompt))
|
|
(set infile-sym (pr-dosify-file-name (symbol-value infile-sym)))
|
|
;; output file
|
|
(and (eq (symbol-value outfile-sym) t)
|
|
(set outfile-sym (and current-prefix-arg
|
|
(pr-ps-outfile-preprint prompt))))
|
|
(and (symbol-value outfile-sym)
|
|
(set outfile-sym (pr-dosify-file-name (symbol-value outfile-sym))))
|
|
(pr-ps-file (symbol-value outfile-sym)))
|
|
|
|
|
|
(defun pr-ps-utility-process (n-up infile outfile)
|
|
;; activate utility to process a PostScript file.
|
|
(let (item)
|
|
(and (stringp infile) (file-exists-p infile)
|
|
(setq item (cdr (assq pr-ps-utility pr-ps-utility-alist)))
|
|
(pr-call-process (nth 0 item)
|
|
(pr-switches-string (nth 1 item)
|
|
"pr-ps-utility-alist entry")
|
|
(pr-switches-string (nth 8 item)
|
|
"pr-ps-utility-alist entry")
|
|
(and (nth 2 item)
|
|
(format (nth 2 item) ps-paper-type))
|
|
(format (nth 3 item) n-up)
|
|
(and pr-file-landscape (nth 4 item))
|
|
(and pr-file-duplex (nth 5 item))
|
|
(and pr-file-tumble (nth 6 item))
|
|
(pr-expand-file-name infile)
|
|
(nth 7 item)
|
|
(pr-expand-file-name outfile)))))
|
|
|
|
|
|
(defun pr-remove-nil-from-list (lst)
|
|
(while (and lst (null (car lst)))
|
|
(setq lst (cdr lst)))
|
|
(let ((b lst)
|
|
(l (cdr lst)))
|
|
(while l
|
|
(if (car l)
|
|
(setq b l
|
|
l (cdr l))
|
|
(setq l (cdr l))
|
|
(setcdr b l))))
|
|
lst)
|
|
|
|
|
|
(defun pr-call-process (command &rest args)
|
|
(let ((buffer (get-buffer-create "*Printing Command Output*"))
|
|
(cmd (pr-command command))
|
|
status)
|
|
(setq args (pr-remove-nil-from-list args))
|
|
;; *Printing Command Output* == show command & args
|
|
(save-excursion
|
|
(set-buffer buffer)
|
|
(goto-char (point-max))
|
|
(insert (format "%s %S\n" cmd args)))
|
|
;; *Printing Command Output* == show any return message from command
|
|
(pr-save-file-modes
|
|
(setq status
|
|
(condition-case data
|
|
(apply 'call-process cmd nil buffer nil args)
|
|
((quit error)
|
|
(error-message-string data)))))
|
|
;; *Printing Command Output* == show exit status
|
|
(save-excursion
|
|
(set-buffer buffer)
|
|
(goto-char (point-max))
|
|
(insert (format "Exit status: %s\n\n" status)))
|
|
;; message if error status
|
|
(if (or (stringp status)
|
|
(and (integerp status) (/= status 0)))
|
|
(message
|
|
"Printing error status: %s (see *Printing Command Output* buffer)"
|
|
status))))
|
|
|
|
|
|
(defun pr-txt-print (from to)
|
|
(let ((lpr-command (pr-standard-file-name (pr-command pr-txt-command)))
|
|
(lpr-switches (pr-switches pr-txt-switches "pr-txt-switches"))
|
|
(printer-name pr-txt-printer))
|
|
(lpr-region from to)))
|
|
|
|
|
|
(defun pr-switches-string (switches mess)
|
|
;; If SWITCHES is nil, return nil.
|
|
;; Otherwise, return the list of string in a string.
|
|
(and switches
|
|
(mapconcat 'identity (pr-switches switches mess) " ")))
|
|
|
|
|
|
(defun pr-switches (switches mess)
|
|
(or (listp switches)
|
|
(error "%S should have a list of strings" mess))
|
|
(ps-flatten-list ; dynamic evaluation
|
|
(mapcar 'ps-eval-switch switches)))
|
|
|
|
|
|
(defun pr-ps-preview (kind n-up filename mess)
|
|
(pr-set-n-up-and-filename 'n-up 'filename mess)
|
|
(let ((file (pr-ps-file filename)))
|
|
(pr-text2ps kind n-up file)
|
|
(or pr-spool-p (pr-ps-file-preview file))))
|
|
|
|
|
|
(defun pr-ps-using-ghostscript (kind n-up filename mess)
|
|
(pr-set-n-up-and-filename 'n-up 'filename mess)
|
|
(let ((file (pr-ps-file filename)))
|
|
(pr-text2ps kind n-up file)
|
|
(unless (or pr-spool-p filename)
|
|
(pr-ps-file-using-ghostscript file)
|
|
(pr-delete-file file))))
|
|
|
|
|
|
(defun pr-ps-print (kind n-up filename mess)
|
|
(pr-set-n-up-and-filename 'n-up 'filename mess)
|
|
(let ((file (pr-ps-file filename)))
|
|
(pr-text2ps kind n-up file)
|
|
(unless (or pr-spool-p filename)
|
|
(pr-ps-file-print file)
|
|
(pr-delete-file file))))
|
|
|
|
|
|
(defun pr-ps-file (&optional filename)
|
|
(pr-dosify-file-name (or filename
|
|
(make-temp-file
|
|
(convert-standard-filename
|
|
(expand-file-name pr-ps-temp-file pr-temp-dir))
|
|
nil ".ps"))))
|
|
|
|
|
|
(defun pr-interactive-n-up (mess)
|
|
(or (stringp mess) (setq mess "*"))
|
|
(save-match-data
|
|
(let* ((fmt-prompt "%s[%s] N-up printing: (default 1) ")
|
|
(prompt "")
|
|
(str (pr-f-read-string (format fmt-prompt prompt mess) "1" nil "1"))
|
|
int)
|
|
(while (if (string-match "^\\s *[0-9]+$" str)
|
|
(setq int (string-to-number str)
|
|
prompt (cond ((< int 1) "Integer below 1; ")
|
|
((> int 100) "Integer above 100; ")
|
|
(t nil)))
|
|
(setq prompt "Invalid integer syntax; "))
|
|
(ding)
|
|
(setq str
|
|
(pr-f-read-string (format fmt-prompt prompt mess) str nil "1")))
|
|
int)))
|
|
|
|
|
|
(defun pr-interactive-dir (mess)
|
|
(let* ((dir-name (file-name-directory (or (buffer-file-name)
|
|
default-directory)))
|
|
(fmt-prompt (concat "%s[" mess "] Directory to print: "))
|
|
(dir (read-file-name (format fmt-prompt "")
|
|
"" dir-name nil dir-name))
|
|
prompt)
|
|
(while (cond ((not (file-directory-p dir))
|
|
(ding)
|
|
(setq prompt "It's not a directory! "))
|
|
((not (file-readable-p dir))
|
|
(ding)
|
|
(setq prompt "Directory is unreadable! "))
|
|
(t nil))
|
|
(setq dir-name (file-name-directory dir)
|
|
dir (read-file-name (format fmt-prompt prompt)
|
|
"" dir-name nil dir-name)))
|
|
(file-name-as-directory dir)))
|
|
|
|
|
|
(defun pr-interactive-regexp (mess)
|
|
(pr-f-read-string (format "[%s] File regexp to print: " mess) "" nil ""))
|
|
|
|
|
|
(defun pr-interactive-dir-args (mess)
|
|
(list
|
|
;; get directory argument
|
|
(pr-interactive-dir mess)
|
|
;; get file name regexp
|
|
(pr-interactive-regexp mess)))
|
|
|
|
|
|
(defun pr-interactive-ps-dir-args (mess)
|
|
(list
|
|
;; get n-up argument
|
|
(pr-interactive-n-up mess)
|
|
;; get directory argument
|
|
(pr-interactive-dir mess)
|
|
;; get file name regexp
|
|
(pr-interactive-regexp mess)
|
|
;; get output file name
|
|
(and (not pr-spool-p)
|
|
(ps-print-preprint current-prefix-arg))))
|
|
|
|
|
|
(defun pr-interactive-n-up-file (mess)
|
|
(list
|
|
;; get n-up argument
|
|
(pr-interactive-n-up mess)
|
|
;; get output file name
|
|
(and (not pr-spool-p)
|
|
(ps-print-preprint current-prefix-arg))))
|
|
|
|
|
|
(defun pr-interactive-n-up-inout (mess)
|
|
(list
|
|
;; get n-up argument
|
|
(pr-interactive-n-up mess)
|
|
;; get input file name
|
|
(pr-ps-infile-preprint (concat mess " "))
|
|
;; get output file name
|
|
(ps-print-preprint current-prefix-arg)))
|
|
|
|
|
|
(defun pr-set-outfilename (filename-sym)
|
|
(and (not pr-spool-p)
|
|
(eq (symbol-value filename-sym) t)
|
|
(set filename-sym (and current-prefix-arg
|
|
(ps-print-preprint current-prefix-arg))))
|
|
(and (symbol-value filename-sym)
|
|
(set filename-sym (pr-dosify-file-name (symbol-value filename-sym)))))
|
|
|
|
|
|
(defun pr-set-n-up-and-filename (n-up-sym filename-sym mess)
|
|
;; n-up
|
|
(or (symbol-value n-up-sym)
|
|
(set n-up-sym (pr-interactive-n-up mess)))
|
|
;; output file
|
|
(pr-set-outfilename filename-sym))
|
|
|
|
|
|
(defun pr-set-dir-args (dir-sym regexp-sym mess)
|
|
;; directory
|
|
(or (symbol-value dir-sym)
|
|
(set dir-sym (pr-interactive-dir mess)))
|
|
;; file name regexp
|
|
(or (symbol-value regexp-sym)
|
|
(set regexp-sym (pr-interactive-regexp mess))))
|
|
|
|
|
|
(defun pr-set-ps-dir-args (n-up-sym dir-sym regexp-sym filename-sym mess)
|
|
;; n-up
|
|
(or (symbol-value n-up-sym)
|
|
(set n-up-sym (pr-interactive-n-up mess)))
|
|
;; directory & file name regexp
|
|
(pr-set-dir-args dir-sym regexp-sym mess)
|
|
;; output file
|
|
(pr-set-outfilename filename-sym))
|
|
|
|
|
|
(defun pr-find-buffer-visiting (file)
|
|
(if (not (file-directory-p file))
|
|
(find-buffer-visiting (if ps-windows-system
|
|
(downcase file)
|
|
file))
|
|
(let ((truename (file-truename file))
|
|
(blist (buffer-list))
|
|
found)
|
|
(while (and (not found) blist)
|
|
(save-excursion
|
|
(set-buffer (car blist))
|
|
(and (eq major-mode 'dired-mode)
|
|
(save-excursion
|
|
(goto-char (point-min))
|
|
(string= (buffer-substring-no-properties
|
|
(+ (point-min) 2)
|
|
(progn
|
|
(end-of-line)
|
|
(1- (point))))
|
|
truename))
|
|
(setq found (car blist))))
|
|
(setq blist (cdr blist)))
|
|
found)))
|
|
|
|
|
|
(defun pr-file-list (dir file-regexp fun)
|
|
(mapcar #'(lambda (file)
|
|
(and (or pr-list-directory
|
|
(not (file-directory-p file)))
|
|
(let ((buffer (pr-find-buffer-visiting file))
|
|
pop-up-windows
|
|
pop-up-frames)
|
|
(and (or buffer
|
|
(file-readable-p file))
|
|
(save-excursion
|
|
(set-buffer (or buffer
|
|
(find-file-noselect file)))
|
|
(funcall fun)
|
|
(or buffer
|
|
(kill-buffer (current-buffer))))))))
|
|
(directory-files dir t file-regexp)))
|
|
|
|
|
|
(defun pr-delete-file-if-exists (filename)
|
|
(and (not pr-spool-p) (stringp filename) (file-exists-p filename)
|
|
(delete-file filename)))
|
|
|
|
|
|
(defun pr-ps-file-list (n-up dir file-regexp filename)
|
|
(pr-delete-file-if-exists (setq filename (pr-expand-file-name filename)))
|
|
(let ((pr-spool-p t))
|
|
(pr-file-list dir file-regexp
|
|
#'(lambda ()
|
|
(if (pr-auto-mode-p)
|
|
(pr-ps-mode n-up filename)
|
|
(pr-text2ps 'buffer n-up filename)))))
|
|
(or pr-spool-p
|
|
(pr-despool-print filename)))
|
|
|
|
|
|
(defun pr-text2ps (kind n-up filename &optional from to)
|
|
(pr-save-file-modes
|
|
(let ((ps-n-up-printing n-up)
|
|
(ps-spool-config (and (eq ps-spool-config 'setpagedevice)
|
|
'setpagedevice)))
|
|
(pr-delete-file-if-exists filename)
|
|
(cond (pr-faces-p
|
|
(cond (pr-spool-p
|
|
;; pr-faces-p and pr-spool-p
|
|
;; here FILENAME arg is ignored
|
|
(cond ((eq kind 'buffer)
|
|
(ps-spool-buffer-with-faces))
|
|
((eq kind 'region)
|
|
(ps-spool-region-with-faces (or from (point))
|
|
(or to (mark))))
|
|
))
|
|
;; pr-faces-p and not pr-spool-p
|
|
((eq kind 'buffer)
|
|
(ps-print-buffer-with-faces filename))
|
|
((eq kind 'region)
|
|
(ps-print-region-with-faces (or from (point))
|
|
(or to (mark)) filename))
|
|
))
|
|
(pr-spool-p
|
|
;; not pr-faces-p and pr-spool-p
|
|
;; here FILENAME arg is ignored
|
|
(cond ((eq kind 'buffer)
|
|
(ps-spool-buffer))
|
|
((eq kind 'region)
|
|
(ps-spool-region (or from (point)) (or to (mark))))
|
|
))
|
|
;; not pr-faces-p and not pr-spool-p
|
|
((eq kind 'buffer)
|
|
(ps-print-buffer filename))
|
|
((eq kind 'region)
|
|
(ps-print-region (or from (point)) (or to (mark)) filename))
|
|
))))
|
|
|
|
|
|
(defun pr-command (command)
|
|
"Return absolute file name specification for COMMAND.
|
|
|
|
If COMMAND is an empty string, return it.
|
|
|
|
If COMMAND is already an absolute file name specification, return it.
|
|
Else it uses `pr-path-alist' to find COMMAND, if find it then return it;
|
|
otherwise, gives an error.
|
|
|
|
When using `pr-path-alist' to find COMMAND, the entries `cygwin', `windows' and
|
|
`unix' are used (see `pr-path-alist' for documentation).
|
|
|
|
If Emacs is running on Windows 95/98/NT/2000, tries to find COMMAND,
|
|
COMMAND.exe, COMMAND.bat and COMMAND.com in this order."
|
|
(if (string= command "")
|
|
command
|
|
(pr-dosify-file-name
|
|
(or (pr-find-command command)
|
|
(pr-path-command (cond (pr-cygwin-system 'cygwin)
|
|
(ps-windows-system 'windows)
|
|
(t 'unix))
|
|
(file-name-nondirectory command)
|
|
nil)
|
|
(error "Command not found: %s"
|
|
(file-name-nondirectory command))))))
|
|
|
|
|
|
(defun pr-path-command (symbol command sym-list)
|
|
(let ((lpath (cdr (assq symbol pr-path-alist)))
|
|
cmd)
|
|
;; PATH expansion
|
|
(and (eq symbol 'PATH) (null lpath)
|
|
(setq lpath (parse-colon-path (getenv "PATH"))))
|
|
(while (and lpath
|
|
(not
|
|
(setq cmd
|
|
(let ((path (car lpath)))
|
|
(cond
|
|
;; symbol expansion
|
|
((symbolp path)
|
|
(and (not (memq path sym-list))
|
|
(pr-path-command path command
|
|
(cons path sym-list))))
|
|
;; normal path
|
|
((stringp path)
|
|
(pr-find-command
|
|
(expand-file-name
|
|
(substitute-in-file-name
|
|
(concat (file-name-as-directory path)
|
|
command)))))
|
|
)))))
|
|
(setq lpath (cdr lpath)))
|
|
cmd))
|
|
|
|
|
|
(defun pr-find-command (cmd)
|
|
(if ps-windows-system
|
|
;; windows system
|
|
(let ((ext (cons (file-name-extension cmd t)
|
|
(list ".exe" ".bat" ".com")))
|
|
found)
|
|
(setq cmd (file-name-sans-extension cmd))
|
|
(while (and ext
|
|
(setq found (concat cmd (car ext)))
|
|
(not (and (file-regular-p found)
|
|
(file-executable-p found))))
|
|
(setq ext (cdr ext)
|
|
found nil))
|
|
found)
|
|
;; non-windows systems
|
|
(and (file-regular-p cmd)
|
|
(file-executable-p cmd)
|
|
cmd)))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Printing Interface (inspired on ps-print-interface.el)
|
|
|
|
|
|
(require 'widget)
|
|
(require 'wid-edit)
|
|
(require 'cus-edit)
|
|
|
|
|
|
(defvar pr-i-window-configuration nil)
|
|
|
|
(defvar pr-i-buffer nil)
|
|
(defvar pr-i-region nil)
|
|
(defvar pr-i-mode nil)
|
|
(defvar pr-i-despool nil)
|
|
(defvar pr-i-ps-as-is t)
|
|
(defvar pr-i-n-up 1)
|
|
(defvar pr-i-directory "./")
|
|
(defvar pr-i-regexp "")
|
|
(defvar pr-i-ps-file "")
|
|
(defvar pr-i-out-file "")
|
|
(defvar pr-i-answer-yes nil)
|
|
(defvar pr-i-process 'buffer)
|
|
(defvar pr-i-ps-send 'printer)
|
|
|
|
|
|
(defvar pr-interface-map nil
|
|
"Keymap for pr-interface.")
|
|
|
|
(unless pr-interface-map
|
|
(setq pr-interface-map (make-sparse-keymap))
|
|
(cond ((featurep 'xemacs) ; XEmacs
|
|
(pr-f-set-keymap-parents pr-interface-map (list widget-keymap))
|
|
(pr-f-set-keymap-name pr-interface-map 'pr-interface-map))
|
|
(t ; GNU Emacs
|
|
(pr-f-set-keymap-parents pr-interface-map widget-keymap)))
|
|
(define-key pr-interface-map "q" 'pr-interface-quit)
|
|
(define-key pr-interface-map "?" 'pr-interface-help))
|
|
|
|
|
|
(defmacro pr-interface-save (&rest body)
|
|
`(save-excursion
|
|
(set-buffer pr-i-buffer)
|
|
,@body))
|
|
|
|
|
|
(defun pr-create-interface ()
|
|
"Create the front end for printing package."
|
|
(setq pr-i-buffer (buffer-name (current-buffer))
|
|
pr-i-region (ps-mark-active-p)
|
|
pr-i-mode (pr-mode-alist-p)
|
|
pr-i-window-configuration (current-window-configuration))
|
|
|
|
(put 'pr-i-process 'pr-widget-list nil)
|
|
(put 'pr-i-ps-send 'pr-widget-list nil)
|
|
|
|
(delete-other-windows)
|
|
(kill-buffer (get-buffer-create pr-buffer-name))
|
|
(switch-to-buffer (get-buffer-create pr-buffer-name))
|
|
|
|
;; header
|
|
(let ((versions (concat "printing v" pr-version
|
|
" ps-print v" ps-print-version)))
|
|
(widget-insert (make-string (- 79 (length versions)) ?\s) versions))
|
|
(pr-insert-italic "\nCurrent Directory : " 1)
|
|
(pr-insert-italic default-directory)
|
|
|
|
(pr-insert-section-1) ; 1. Print
|
|
(pr-insert-section-2) ; 2. PostScript Printer
|
|
(pr-insert-section-3) ; 3. Text Printer
|
|
|
|
;; separator
|
|
(widget-insert "\n\n " (make-string 77 ?-))
|
|
|
|
(pr-insert-section-4) ; 4. Settings
|
|
(pr-insert-section-5) ; 5. Customize
|
|
(pr-insert-section-6) ; 6. Show Settings
|
|
(pr-insert-section-7) ; 7. Help
|
|
|
|
(use-local-map pr-interface-map)
|
|
(widget-setup)
|
|
(goto-char (point-min))
|
|
|
|
(and pr-i-region ; let region activated
|
|
(pr-keep-region-active)))
|
|
|
|
|
|
(defun pr-insert-section-1 ()
|
|
;; 1. Print:
|
|
(pr-insert-italic "\nPrint :" 1)
|
|
|
|
;; 1a. Buffer:
|
|
;; 1a. Buffer: Buffer List
|
|
(pr-insert-radio-button 'pr-i-process 'buffer)
|
|
(pr-insert-menu "Buffer List" 'pr-i-buffer
|
|
(let ((blist (buffer-list))
|
|
case-fold-search choices)
|
|
(while blist
|
|
(let ((name (buffer-name (car blist)))
|
|
(ignore pr-buffer-name-ignore)
|
|
found)
|
|
(setq blist (cdr blist))
|
|
(while (and ignore (not found))
|
|
(setq found (string-match (car ignore) name)
|
|
ignore (cdr ignore)))
|
|
(or found
|
|
(setq choices
|
|
(cons (list 'quote
|
|
(list 'choice-item
|
|
:format "%[%t%]"
|
|
name))
|
|
choices)))))
|
|
(nreverse choices))
|
|
" Buffer : " nil
|
|
'(progn
|
|
(pr-interface-save
|
|
(setq pr-i-region (ps-mark-active-p)
|
|
pr-i-mode (pr-mode-alist-p)))
|
|
(pr-update-checkbox 'pr-i-region)
|
|
(pr-update-checkbox 'pr-i-mode)))
|
|
;; 1a. Buffer: Region
|
|
(put 'pr-i-region 'pr-widget
|
|
(pr-insert-checkbox
|
|
"\n "
|
|
'pr-i-region
|
|
#'(lambda (widget &rest ignore)
|
|
(let ((region-p (pr-interface-save
|
|
(ps-mark-active-p))))
|
|
(cond ((null (widget-value widget)) ; widget is nil
|
|
(setq pr-i-region nil))
|
|
(region-p ; widget is true and there is a region
|
|
(setq pr-i-region t)
|
|
(widget-value-set widget t)
|
|
(widget-setup)) ; MUST be called after widget-value-set
|
|
(t ; widget is true and there is no region
|
|
(ding)
|
|
(message "There is no region active")
|
|
(setq pr-i-region nil)
|
|
(widget-value-set widget nil)
|
|
(widget-setup))))) ; MUST be called after widget-value-set
|
|
" Region"))
|
|
;; 1a. Buffer: Mode
|
|
(put 'pr-i-mode 'pr-widget
|
|
(pr-insert-checkbox
|
|
" "
|
|
'pr-i-mode
|
|
#'(lambda (widget &rest ignore)
|
|
(let ((mode-p (pr-interface-save
|
|
(pr-mode-alist-p))))
|
|
(cond
|
|
((null (widget-value widget)) ; widget is nil
|
|
(setq pr-i-mode nil))
|
|
(mode-p ; widget is true and there is a `mode'
|
|
(setq pr-i-mode t)
|
|
(widget-value-set widget t)
|
|
(widget-setup)) ; MUST be called after widget-value-set
|
|
(t ; widget is true and there is no `mode'
|
|
(ding)
|
|
(message
|
|
"This buffer isn't in a mode that printing treats specially.")
|
|
(setq pr-i-mode nil)
|
|
(widget-value-set widget nil)
|
|
(widget-setup))))) ; MUST be called after widget-value-set
|
|
" Mode\n"))
|
|
|
|
;; 1b. Directory:
|
|
(pr-insert-radio-button 'pr-i-process 'directory)
|
|
(widget-create
|
|
'directory
|
|
:size 58
|
|
:format " Directory : %v"
|
|
:notify 'pr-interface-directory
|
|
:action (lambda (widget &optional event)
|
|
(if (pr-interface-directory widget)
|
|
(pr-widget-field-action widget event)
|
|
(ding)
|
|
(message "Please specify a readable directory")))
|
|
pr-i-directory)
|
|
;; 1b. Directory: File Regexp
|
|
(widget-create 'regexp
|
|
:size 58
|
|
:format "\n File Regexp : %v\n"
|
|
:notify (lambda (widget &rest ignore)
|
|
(setq pr-i-regexp (widget-value widget)))
|
|
pr-i-regexp)
|
|
;; 1b. Directory: List Directory Entry
|
|
(widget-insert " ")
|
|
(pr-insert-toggle 'pr-list-directory " List Directory Entry\n")
|
|
|
|
;; 1c. PostScript File:
|
|
(pr-insert-radio-button 'pr-i-process 'file)
|
|
(widget-create
|
|
'file
|
|
:size 51
|
|
:format " PostScript File : %v"
|
|
:notify 'pr-interface-infile
|
|
:action (lambda (widget &rest event)
|
|
(if (pr-interface-infile widget)
|
|
(pr-widget-field-action widget event)
|
|
(ding)
|
|
(message "Please specify a readable PostScript file")))
|
|
pr-i-ps-file)
|
|
;; 1c. PostScript File: PostScript Utility
|
|
(pr-insert-menu "PostScript Utility" 'pr-ps-utility
|
|
(pr-choice-alist pr-ps-utility-alist)
|
|
"\n PostScript Utility : "
|
|
" ")
|
|
;; 1c. PostScript File: No Preprocessing
|
|
(pr-insert-toggle 'pr-i-ps-as-is " No Preprocessing"))
|
|
|
|
|
|
(defun pr-insert-section-2 ()
|
|
;; 2. PostScript Printer:
|
|
;; 2. PostScript Printer: PostScript Printer List
|
|
(pr-insert-italic "\n\nPostScript Printer : " 2 20)
|
|
(pr-insert-menu "PostScript Printer" 'pr-ps-name
|
|
(pr-choice-alist pr-ps-printer-alist))
|
|
;; 2. PostScript Printer: Despool
|
|
(put 'pr-i-despool 'pr-widget
|
|
(pr-insert-checkbox
|
|
" "
|
|
'pr-i-despool
|
|
#'(lambda (widget &rest ignore)
|
|
(if pr-spool-p
|
|
(setq pr-i-despool (not pr-i-despool))
|
|
(ding)
|
|
(message "Can despool only when spooling is actually selected")
|
|
(setq pr-i-despool nil))
|
|
(widget-value-set widget pr-i-despool)
|
|
(widget-setup)) ; MUST be called after widget-value-set
|
|
" Despool "))
|
|
;; 2. PostScript Printer: Preview Print Quit
|
|
(pr-insert-button 'pr-interface-preview "Preview" " ")
|
|
(pr-insert-button 'pr-interface-ps-print "Print" " ")
|
|
(pr-insert-button 'pr-interface-quit "Quit")
|
|
;; 2. PostScript Printer: Send to Printer/Temporary File
|
|
(pr-insert-radio-button 'pr-i-ps-send 'printer)
|
|
(widget-insert " Send to Printer/Temporary File")
|
|
;; 2. PostScript Printer: Send to File
|
|
(pr-insert-radio-button 'pr-i-ps-send 'file)
|
|
(widget-create
|
|
'file
|
|
:size 57
|
|
:format " Send to File : %v"
|
|
:notify 'pr-interface-outfile
|
|
:action (lambda (widget &rest event)
|
|
(if (and (pr-interface-outfile widget)
|
|
(or (not (file-exists-p pr-i-out-file))
|
|
(setq pr-i-answer-yes
|
|
(y-or-n-p "File exists; overwrite? "))))
|
|
(pr-widget-field-action widget event)
|
|
(ding)
|
|
(message "Please specify a writable PostScript file")))
|
|
pr-i-out-file)
|
|
;; 2. PostScript Printer: N-Up
|
|
(widget-create
|
|
'integer
|
|
:size 3
|
|
:format "\n N-Up : %v"
|
|
:notify (lambda (widget &rest ignore)
|
|
(let ((value (if (string= (widget-apply widget :value-get) "")
|
|
0
|
|
(widget-value widget))))
|
|
(if (and (integerp value)
|
|
(<= 1 value) (<= value 100))
|
|
(progn
|
|
(message " ")
|
|
(setq pr-i-n-up value))
|
|
(ding)
|
|
(message "Please specify an integer between 1 and 100"))))
|
|
pr-i-n-up))
|
|
|
|
|
|
(defun pr-insert-section-3 ()
|
|
;; 3. Text Printer:
|
|
(pr-insert-italic "\n\nText Printer : " 2 14)
|
|
(pr-insert-menu "Text Printer" 'pr-txt-name
|
|
(pr-choice-alist pr-txt-printer-alist)
|
|
nil " ")
|
|
(pr-insert-button 'pr-interface-printify "Printify" " ")
|
|
(pr-insert-button 'pr-interface-txt-print "Print" " ")
|
|
(pr-insert-button 'pr-interface-quit "Quit"))
|
|
|
|
|
|
(defun pr-insert-section-4 ()
|
|
;; 4. Settings:
|
|
;; 4. Settings: Landscape Auto Region Verbose
|
|
(pr-insert-checkbox "\n\n " 'ps-landscape-mode
|
|
#'(lambda (&rest ignore)
|
|
(setq ps-landscape-mode (not ps-landscape-mode)
|
|
pr-file-landscape ps-landscape-mode))
|
|
" Landscape ")
|
|
(pr-insert-toggle 'pr-auto-region " Auto Region ")
|
|
(pr-insert-toggle 'pr-buffer-verbose " Verbose\n ")
|
|
|
|
;; 4. Settings: Print Header Auto Mode
|
|
(pr-insert-toggle 'ps-print-header " Print Header ")
|
|
(pr-insert-toggle 'pr-auto-mode " Auto Mode\n ")
|
|
|
|
;; 4. Settings: Print Header Frame Menu Lock
|
|
(pr-insert-toggle 'ps-print-header-frame " Print Header Frame ")
|
|
(pr-insert-toggle 'pr-menu-lock " Menu Lock\n ")
|
|
|
|
;; 4. Settings: Line Number
|
|
(pr-insert-toggle 'ps-line-number " Line Number\n ")
|
|
|
|
;; 4. Settings: Zebra Stripes Spool Buffer
|
|
(pr-insert-toggle 'ps-zebra-stripes " Zebra Stripes")
|
|
(pr-insert-checkbox " "
|
|
'pr-spool-p
|
|
#'(lambda (&rest ignore)
|
|
(setq pr-spool-p (not pr-spool-p))
|
|
(unless pr-spool-p
|
|
(setq pr-i-despool nil)
|
|
(pr-update-checkbox 'pr-i-despool)))
|
|
" Spool Buffer")
|
|
|
|
;; 4. Settings: Duplex Print with faces
|
|
(pr-insert-checkbox "\n "
|
|
'ps-spool-duplex
|
|
#'(lambda (&rest ignore)
|
|
(setq ps-spool-duplex (not ps-spool-duplex)
|
|
pr-file-duplex ps-spool-duplex))
|
|
" Duplex ")
|
|
(pr-insert-toggle 'pr-faces-p " Print with faces")
|
|
|
|
;; 4. Settings: Tumble Print via Ghostscript
|
|
(pr-insert-checkbox "\n "
|
|
'ps-spool-tumble
|
|
#'(lambda (&rest ignore)
|
|
(setq ps-spool-tumble (not ps-spool-tumble)
|
|
pr-file-tumble ps-spool-tumble))
|
|
" Tumble ")
|
|
(pr-insert-toggle 'pr-print-using-ghostscript " Print via Ghostscript\n ")
|
|
|
|
;; 4. Settings: Upside-Down Page Parity
|
|
(pr-insert-toggle 'ps-print-upside-down " Upside-Down")
|
|
(pr-insert-italic "\n\nSelect Pages : " 2 14)
|
|
(pr-insert-menu "Page Parity" 'ps-even-or-odd-pages
|
|
(mapcar #'(lambda (alist)
|
|
(list 'quote
|
|
(list 'choice-item
|
|
:format "%[%t%]"
|
|
:tag (cdr alist)
|
|
:value (car alist))))
|
|
pr-even-or-odd-alist)))
|
|
|
|
|
|
(defun pr-insert-section-5 ()
|
|
;; 5. Customize:
|
|
(pr-insert-italic "\n\nCustomize : " 2 11)
|
|
(pr-insert-button 'pr-customize "printing" " ")
|
|
(pr-insert-button #'(lambda (&rest ignore) (ps-print-customize))
|
|
"ps-print" " ")
|
|
(pr-insert-button 'lpr-customize "lpr"))
|
|
|
|
|
|
(defun pr-insert-section-6 ()
|
|
;; 6. Show Settings:
|
|
(pr-insert-italic "\nShow Settings : " 1 14)
|
|
(pr-insert-button 'pr-show-pr-setup "printing" " ")
|
|
(pr-insert-button 'pr-show-ps-setup "ps-print" " ")
|
|
(pr-insert-button 'pr-show-lpr-setup "lpr"))
|
|
|
|
|
|
(defun pr-insert-section-7 ()
|
|
;; 7. Help:
|
|
(pr-insert-italic "\nHelp : " 1 5)
|
|
(pr-insert-button 'pr-interface-help "Interface Help" " ")
|
|
(pr-insert-button 'pr-help "Menu Help" " ")
|
|
(pr-insert-button 'pr-interface-quit "Quit" "\n ")
|
|
(pr-insert-button 'pr-kill-help "Kill All Printing Help Buffer"))
|
|
|
|
|
|
(defun pr-kill-help (&rest ignore)
|
|
"Kill all printing help buffer."
|
|
(interactive)
|
|
(let ((help '("*Printing Interface Help*" "*Printing Help*"
|
|
"*LPR Setup*" "*PR Setup*" "*PS Setup*")))
|
|
(while help
|
|
(let ((buffer (get-buffer (car help))))
|
|
(setq help (cdr help))
|
|
(when buffer
|
|
(delete-windows-on buffer)
|
|
(kill-buffer buffer)))))
|
|
(recenter (- (window-height) 2)))
|
|
|
|
|
|
(defun pr-interface-quit (&rest ignore)
|
|
"Kill the printing buffer interface and quit."
|
|
(interactive)
|
|
(kill-buffer pr-buffer-name)
|
|
(set-window-configuration pr-i-window-configuration))
|
|
|
|
|
|
(defun pr-interface-help (&rest ignore)
|
|
"printing buffer interface help."
|
|
(interactive)
|
|
(pr-show-setup pr-interface-help-message "*Printing Interface Help*"))
|
|
|
|
|
|
(defun pr-interface-txt-print (&rest ignore)
|
|
"Print using lpr package."
|
|
(interactive)
|
|
(condition-case data
|
|
(cond
|
|
((eq pr-i-process 'directory)
|
|
(pr-i-directory)
|
|
(pr-interface-save
|
|
(pr-txt-directory pr-i-directory pr-i-regexp)))
|
|
((eq pr-i-process 'buffer)
|
|
(pr-interface-save
|
|
(cond (pr-i-region
|
|
(let ((pr-auto-mode pr-i-mode))
|
|
(pr-txt-region)))
|
|
(pr-i-mode
|
|
(let (pr-auto-region)
|
|
(pr-txt-mode)))
|
|
(t
|
|
(let (pr-auto-mode pr-auto-region)
|
|
(pr-txt-buffer)))
|
|
)))
|
|
((eq pr-i-process 'file)
|
|
(error "Please specify a text file"))
|
|
(t
|
|
(error "Internal error: `pr-i-process' = %S" pr-i-process))
|
|
)
|
|
;; handlers
|
|
((quit error)
|
|
(ding)
|
|
(message "%s" (error-message-string data)))))
|
|
|
|
|
|
(defun pr-interface-printify (&rest ignore)
|
|
"Printify a buffer."
|
|
(interactive)
|
|
(condition-case data
|
|
(cond
|
|
((eq pr-i-process 'directory)
|
|
(pr-i-directory)
|
|
(pr-interface-save
|
|
(pr-printify-directory pr-i-directory pr-i-regexp)))
|
|
((eq pr-i-process 'buffer)
|
|
(pr-interface-save
|
|
(if pr-i-region
|
|
(pr-printify-region)
|
|
(pr-printify-buffer))))
|
|
((eq pr-i-process 'file)
|
|
(error "Cannot printify a PostScript file"))
|
|
(t
|
|
(error "Internal error: `pr-i-process' = %S" pr-i-process))
|
|
)
|
|
;; handlers
|
|
((quit error)
|
|
(ding)
|
|
(message "%s" (error-message-string data)))))
|
|
|
|
|
|
(defun pr-interface-ps-print (&rest ignore)
|
|
"Print using ps-print package."
|
|
(interactive)
|
|
(pr-interface-ps 'pr-despool-ps-print 'pr-ps-directory-ps-print
|
|
'pr-ps-file-ps-print 'pr-ps-file-up-ps-print
|
|
'pr-ps-region-ps-print 'pr-ps-mode-ps-print
|
|
'pr-ps-buffer-ps-print))
|
|
|
|
|
|
(defun pr-interface-preview (&rest ignore)
|
|
"Preview a PostScript file."
|
|
(interactive)
|
|
(pr-interface-ps 'pr-despool-preview 'pr-ps-directory-preview
|
|
'pr-ps-file-preview 'pr-ps-file-up-preview
|
|
'pr-ps-region-preview 'pr-ps-mode-preview
|
|
'pr-ps-buffer-preview))
|
|
|
|
|
|
(defun pr-interface-ps (ps-despool ps-directory ps-file ps-file-up ps-region
|
|
ps-mode ps-buffer)
|
|
(condition-case data
|
|
(let ((outfile (or (and (eq pr-i-process 'file) pr-i-ps-as-is)
|
|
(pr-i-ps-send))))
|
|
(cond
|
|
((and pr-i-despool pr-spool-p)
|
|
(pr-interface-save
|
|
(funcall ps-despool outfile))
|
|
(setq pr-i-despool nil)
|
|
(pr-update-checkbox 'pr-i-despool))
|
|
((eq pr-i-process 'directory)
|
|
(pr-i-directory)
|
|
(pr-interface-save
|
|
(funcall ps-directory
|
|
pr-i-n-up pr-i-directory pr-i-regexp outfile)))
|
|
((eq pr-i-process 'file)
|
|
(cond ((or (file-directory-p pr-i-ps-file)
|
|
(not (file-readable-p pr-i-ps-file)))
|
|
(error "Please specify a readable PostScript file"))
|
|
(pr-i-ps-as-is
|
|
(pr-interface-save
|
|
(funcall ps-file pr-i-ps-file)))
|
|
(t
|
|
(pr-interface-save
|
|
(funcall ps-file-up pr-i-n-up pr-i-ps-file outfile)))
|
|
))
|
|
((eq pr-i-process 'buffer)
|
|
(pr-interface-save
|
|
(cond (pr-i-region
|
|
(let ((pr-auto-mode pr-i-mode))
|
|
(funcall ps-region pr-i-n-up outfile)))
|
|
(pr-i-mode
|
|
(let (pr-auto-region)
|
|
(funcall ps-mode pr-i-n-up outfile)))
|
|
(t
|
|
(let (pr-auto-mode pr-auto-region)
|
|
(funcall ps-buffer pr-i-n-up outfile)))
|
|
)))
|
|
(t
|
|
(error "Internal error: `pr-i-process' = %S" pr-i-process))
|
|
))
|
|
;; handlers
|
|
((quit error)
|
|
(ding)
|
|
(message "%s" (error-message-string data)))))
|
|
|
|
|
|
(defun pr-i-ps-send ()
|
|
(cond ((eq pr-i-ps-send 'printer)
|
|
nil)
|
|
((not (eq pr-i-ps-send 'file))
|
|
(error "Internal error: `pr-i-ps-send' = %S" pr-i-ps-send))
|
|
((or (file-directory-p pr-i-out-file)
|
|
(not (file-writable-p pr-i-out-file)))
|
|
(error "Please specify a writable PostScript file"))
|
|
((or (not (file-exists-p pr-i-out-file))
|
|
pr-i-answer-yes
|
|
(setq pr-i-answer-yes
|
|
(y-or-n-p (format "File `%s' exists; overwrite? "
|
|
pr-i-out-file))))
|
|
pr-i-out-file)
|
|
(t
|
|
(error "File already exists"))))
|
|
|
|
|
|
(defun pr-i-directory ()
|
|
(or (and (file-directory-p pr-i-directory)
|
|
(file-readable-p pr-i-directory))
|
|
(error "Please specify be a readable directory")))
|
|
|
|
|
|
(defun pr-interface-directory (widget &rest ignore)
|
|
(and pr-buffer-verbose
|
|
(message "You can use M-TAB or ESC TAB for file completion"))
|
|
(let ((dir (widget-value widget)))
|
|
(and (file-directory-p dir)
|
|
(file-readable-p dir)
|
|
(setq pr-i-directory dir))))
|
|
|
|
|
|
(defun pr-interface-infile (widget &rest ignore)
|
|
(and pr-buffer-verbose
|
|
(message "You can use M-TAB or ESC TAB for file completion"))
|
|
(let ((file (widget-value widget)))
|
|
(and (not (file-directory-p file))
|
|
(file-readable-p file)
|
|
(setq pr-i-ps-file file))))
|
|
|
|
|
|
(defun pr-interface-outfile (widget &rest ignore)
|
|
(setq pr-i-answer-yes nil)
|
|
(and pr-buffer-verbose
|
|
(message "You can use M-TAB or ESC TAB for file completion"))
|
|
(let ((file (widget-value widget)))
|
|
(and (not (file-directory-p file))
|
|
(file-writable-p file)
|
|
(setq pr-i-out-file file))))
|
|
|
|
|
|
(defun pr-widget-field-action (widget event)
|
|
(and (get-buffer "*Completions*") ; clean frame window
|
|
(delete-windows-on "*Completions*"))
|
|
(message " ") ; clean echo area
|
|
(widget-field-action widget event))
|
|
|
|
|
|
(defun pr-insert-italic (str &optional from to)
|
|
(let ((len (length str)))
|
|
(put-text-property (if from (max from 0) 0)
|
|
(if to (max to len) len)
|
|
'face 'italic str)
|
|
(widget-insert str)))
|
|
|
|
|
|
(defun pr-insert-checkbox (before var-sym fun label)
|
|
(widget-insert before)
|
|
(prog1
|
|
(widget-create 'checkbox
|
|
:notify fun
|
|
(symbol-value var-sym))
|
|
(widget-insert label)))
|
|
|
|
|
|
(defun pr-insert-toggle (var-sym label)
|
|
(widget-create 'checkbox
|
|
:notify `(lambda (&rest ignore)
|
|
(setq ,var-sym (not ,var-sym)))
|
|
(symbol-value var-sym))
|
|
(widget-insert label))
|
|
|
|
|
|
(defun pr-insert-button (fun label &optional separator)
|
|
(widget-create 'push-button
|
|
:notify fun
|
|
label)
|
|
(and separator
|
|
(widget-insert separator)))
|
|
|
|
|
|
(defun pr-insert-menu (tag var-sym choices &optional before after &rest body)
|
|
(and before (widget-insert before))
|
|
(eval `(widget-create 'menu-choice
|
|
:tag ,tag
|
|
:format "%v"
|
|
:inline t
|
|
:value ,var-sym
|
|
:notify (lambda (widget &rest ignore)
|
|
(setq ,var-sym (widget-value widget))
|
|
,@body)
|
|
:void '(choice-item :format "%[%t%]"
|
|
:tag "Can not display value!")
|
|
,@choices))
|
|
(and after (widget-insert after)))
|
|
|
|
|
|
(defun pr-insert-radio-button (var-sym sym)
|
|
(widget-insert "\n")
|
|
(let ((wid-list (get var-sym 'pr-widget-list))
|
|
(wid (eval `(widget-create
|
|
'radio-button
|
|
:format " %[%v%]"
|
|
:value (eq ,var-sym (quote ,sym))
|
|
:notify (lambda (&rest ignore)
|
|
(setq ,var-sym (quote ,sym))
|
|
(pr-update-radio-button (quote ,var-sym)))))))
|
|
(put var-sym 'pr-widget-list (cons (cons wid sym) wid-list))))
|
|
|
|
|
|
(defun pr-update-radio-button (var-sym)
|
|
(let ((wid-list (get var-sym 'pr-widget-list)))
|
|
(while wid-list
|
|
(let ((wid (car (car wid-list)))
|
|
(value (cdr (car wid-list))))
|
|
(setq wid-list (cdr wid-list))
|
|
(widget-value-set wid (eq (symbol-value var-sym) value))))
|
|
(widget-setup)))
|
|
|
|
|
|
(defun pr-update-checkbox (var-sym)
|
|
(let ((wid (get var-sym 'pr-widget)))
|
|
(when wid
|
|
(widget-value-set wid (symbol-value var-sym))
|
|
(widget-setup))))
|
|
|
|
|
|
(defun pr-choice-alist (alist)
|
|
(let ((max (apply 'max (mapcar #'(lambda (alist)
|
|
(length (symbol-name (car alist))))
|
|
alist))))
|
|
(mapcar #'(lambda (alist)
|
|
(let* ((sym (car alist))
|
|
(name (symbol-name sym)))
|
|
(list
|
|
'quote
|
|
(list
|
|
'choice-item
|
|
:format "%[%t%]"
|
|
:tag (concat name
|
|
(make-string (- max (length name)) ?_))
|
|
:value sym))))
|
|
alist)))
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
(provide 'printing)
|
|
|
|
|
|
;; arch-tag: 9ce9ac3f-0f60-4370-900b-1943215d9d18
|
|
;;; printing.el ends here
|