mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-28 10:56:36 +00:00
1583 lines
54 KiB
EmacsLisp
1583 lines
54 KiB
EmacsLisp
;;; ps-mule.el --- provide multi-byte character facility to ps-print
|
|
|
|
;; Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
|
|
;; Free Software Foundation, Inc.
|
|
|
|
;; Author: Vinicius Jose Latorre <vinicius@cpqd.com.br>
|
|
;; Kenichi Handa <handa@etl.go.jp> (multi-byte characters)
|
|
;; Maintainer: Kenichi Handa <handa@etl.go.jp> (multi-byte characters)
|
|
;; Vinicius Jose Latorre <vinicius@cpqd.com.br>
|
|
;; Keywords: wp, print, PostScript, multibyte, mule
|
|
;; Time-stamp: <2003/05/14 22:19:41 vinicius>
|
|
|
|
;; 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., 59 Temple Place - Suite 330,
|
|
;; Boston, MA 02111-1307, USA.
|
|
|
|
;;; Commentary:
|
|
|
|
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;; About ps-mule
|
|
;; -------------
|
|
;;
|
|
;; This package is used for ps-print to print multi-byte buffer.
|
|
;;
|
|
;; See also ps-print.el.
|
|
;;
|
|
;;
|
|
;; Printing Multi-byte Buffer
|
|
;; --------------------------
|
|
;;
|
|
;; The variable `ps-multibyte-buffer' specifies the ps-print multi-byte buffer
|
|
;; handling.
|
|
;;
|
|
;; Valid values for `ps-multibyte-buffer' are:
|
|
;;
|
|
;; nil This is the value to use the default settings which
|
|
;; is by default for printing buffer with only ASCII
|
|
;; and Latin characters. The default setting can be
|
|
;; changed by setting the variable
|
|
;; `ps-mule-font-info-database-default' differently.
|
|
;; The initial value of this variable is
|
|
;; `ps-mule-font-info-database-latin' (see
|
|
;; documentation).
|
|
;;
|
|
;; `non-latin-printer' This is the value to use when you have a japanese
|
|
;; or korean PostScript printer and want to print
|
|
;; buffer with ASCII, Latin-1, Japanese (JISX0208 and
|
|
;; JISX0201-Kana) and Korean characters. At present,
|
|
;; it was not tested the Korean characters printing.
|
|
;; If you have a korean PostScript printer, please,
|
|
;; test it.
|
|
;;
|
|
;; `bdf-font' This is the value to use when you want to print
|
|
;; buffer with BDF fonts. BDF fonts include both latin
|
|
;; and non-latin fonts. BDF (Bitmap Distribution
|
|
;; Format) is a format used for distributing X's font
|
|
;; source file. BDF fonts are included in
|
|
;; `intlfonts-1.2' which is a collection of X11 fonts
|
|
;; for all characters supported by Emacs. In order to
|
|
;; use this value, be sure to have installed
|
|
;; `intlfonts-1.2' and set the variable
|
|
;; `bdf-directory-list' appropriately (see ps-bdf.el
|
|
;; for documentation of this variable).
|
|
;;
|
|
;; `bdf-font-except-latin' This is like `bdf-font' except that it is used
|
|
;; PostScript default fonts to print ASCII and Latin-1
|
|
;; characters. This is convenient when you want or
|
|
;; need to use both latin and non-latin characters on
|
|
;; the same buffer. See `ps-font-family',
|
|
;; `ps-header-font-family' and `ps-font-info-database'.
|
|
;;
|
|
;; Any other value is treated as nil.
|
|
;;
|
|
;; The default is nil.
|
|
;;
|
|
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;; Code:
|
|
|
|
(eval-and-compile
|
|
(require 'ps-print)
|
|
|
|
;; to avoid XEmacs compilation gripes
|
|
(defvar leading-code-private-22 157)
|
|
(or (fboundp 'charset-bytes)
|
|
(defun charset-bytes (charset) 1)) ; ascii
|
|
(or (fboundp 'charset-dimension)
|
|
(defun charset-dimension (charset) 1)) ; ascii
|
|
(or (fboundp 'charset-id)
|
|
(defun charset-id (charset) 0)) ; ascii
|
|
(or (fboundp 'charset-width)
|
|
(defun charset-width (charset) 1)) ; ascii
|
|
(or (fboundp 'find-charset-region)
|
|
(defun find-charset-region (beg end &optional table)
|
|
(list 'ascii)))
|
|
(or (fboundp 'char-valid-p)
|
|
(defun char-valid-p (char)
|
|
(< (following-char) 256)))
|
|
(or (fboundp 'split-char)
|
|
(defun split-char (char)
|
|
(list (if (char-valid-p char)
|
|
'ascii
|
|
'unknow)
|
|
char)))
|
|
(or (fboundp 'char-width)
|
|
(defun char-width (char) 1)) ; ascii
|
|
(or (fboundp 'chars-in-region)
|
|
(defun chars-in-region (beg end)
|
|
(- (max beg end) (min beg end))))
|
|
(or (fboundp 'forward-point)
|
|
(defun forward-point (arg)
|
|
(save-excursion
|
|
(let ((count (abs arg))
|
|
(step (if (zerop arg)
|
|
0
|
|
(/ arg arg))))
|
|
(while (and (> count 0)
|
|
(< (point-min) (point)) (< (point) (point-max)))
|
|
(forward-char step)
|
|
(setq count (1- count)))
|
|
(+ (point) (* count step))))))
|
|
(or (fboundp 'decompose-composite-char)
|
|
(defun decompose-composite-char (char &optional type
|
|
with-composition-rule)
|
|
nil))
|
|
(or (fboundp 'encode-coding-string)
|
|
(defun encode-coding-string (string coding-system &optional nocopy)
|
|
(if nocopy
|
|
string
|
|
(copy-sequence string))))
|
|
(or (fboundp 'coding-system-p)
|
|
(defun coding-system-p (obj) nil))
|
|
(or (fboundp 'ccl-execute-on-string)
|
|
(defun ccl-execute-on-string (ccl-prog status str
|
|
&optional contin unibyte-p)
|
|
str))
|
|
(or (fboundp 'define-ccl-program)
|
|
(defmacro define-ccl-program (name ccl-program &optional doc)
|
|
`(defconst ,name nil ,doc)))
|
|
(or (fboundp 'multibyte-string-p)
|
|
(defun multibyte-string-p (str)
|
|
(let ((len (length str))
|
|
(i 0)
|
|
multibyte)
|
|
(while (and (< i len) (not (setq multibyte (> (aref str i) 255))))
|
|
(setq i (1+ i)))
|
|
multibyte)))
|
|
(or (fboundp 'string-make-multibyte)
|
|
(defalias 'string-make-multibyte 'copy-sequence))
|
|
(or (fboundp 'encode-char)
|
|
(defun encode-char (ch ccs)
|
|
ch)))
|
|
|
|
|
|
;;;###autoload
|
|
(defcustom ps-multibyte-buffer nil
|
|
"*Specifies the multi-byte buffer handling.
|
|
|
|
Valid values are:
|
|
|
|
nil This is the value to use the default settings which
|
|
is by default for printing buffer with only ASCII
|
|
and Latin characters. The default setting can be
|
|
changed by setting the variable
|
|
`ps-mule-font-info-database-default' differently.
|
|
The initial value of this variable is
|
|
`ps-mule-font-info-database-latin' (see
|
|
documentation).
|
|
|
|
`non-latin-printer' This is the value to use when you have a Japanese
|
|
or Korean PostScript printer and want to print
|
|
buffer with ASCII, Latin-1, Japanese (JISX0208 and
|
|
JISX0201-Kana) and Korean characters. At present,
|
|
it was not tested the Korean characters printing.
|
|
If you have a korean PostScript printer, please,
|
|
test it.
|
|
|
|
`bdf-font' This is the value to use when you want to print
|
|
buffer with BDF fonts. BDF fonts include both latin
|
|
and non-latin fonts. BDF (Bitmap Distribution
|
|
Format) is a format used for distributing X's font
|
|
source file. BDF fonts are included in
|
|
`intlfonts-1.2' which is a collection of X11 fonts
|
|
for all characters supported by Emacs. In order to
|
|
use this value, be sure to have installed
|
|
`intlfonts-1.2' and set the variable
|
|
`bdf-directory-list' appropriately (see ps-bdf.el for
|
|
documentation of this variable).
|
|
|
|
`bdf-font-except-latin' This is like `bdf-font' except that it is used
|
|
PostScript default fonts to print ASCII and Latin-1
|
|
characters. This is convenient when you want or
|
|
need to use both latin and non-latin characters on
|
|
the same buffer. See `ps-font-family',
|
|
`ps-header-font-family' and `ps-font-info-database'.
|
|
|
|
Any other value is treated as nil."
|
|
:type '(choice (const non-latin-printer) (const bdf-font)
|
|
(const bdf-font-except-latin) (const :tag "nil" nil))
|
|
:group 'ps-print-font)
|
|
|
|
(defvar ps-mule-font-info-database
|
|
nil
|
|
"Alist of charsets with the corresponding font information.
|
|
Each element has the form:
|
|
|
|
(CHARSET (FONT-TYPE FONT-SRC FONT-NAME ENCODING BYTES) ...)
|
|
|
|
Where
|
|
|
|
CHARSET is a charset (symbol) for this font family,
|
|
|
|
FONT-TYPE is a font type: normal, bold, italic, or bold-italic.
|
|
|
|
FONT-SRC is a font source: builtin, bdf, vflib, or nil.
|
|
|
|
If FONT-SRC is builtin, FONT-NAME is a built-in PostScript font name.
|
|
|
|
If FONT-SRC is bdf, FONT-NAME is a BDF font file name, or a list of
|
|
alternative font names. To use this font, the external library `ps-bdf'
|
|
is required.
|
|
|
|
If FONT-SRC is vflib, FONT-NAME is the name of a font that VFlib knows.
|
|
To use this font, the external library `vflib' is required.
|
|
|
|
If FONT-SRC is nil, a proper ASCII font in the variable
|
|
`ps-font-info-database' is used. This is useful for Latin-1 characters.
|
|
|
|
ENCODING is a coding system to encode a string of characters of CHARSET into a
|
|
proper string matching an encoding of the specified font. ENCODING may be a
|
|
function that does this encoding. In this case, the function is called with
|
|
one argument, the string to encode, and it should return an encoded string.
|
|
|
|
BYTES specifies how many bytes each character has in the encoded byte
|
|
sequence; it should be 1 or 2.
|
|
|
|
All multi-byte characters are printed by fonts specified in this database
|
|
regardless of a font family of ASCII characters. The exception is Latin-1
|
|
characters which are printed by the same font as ASCII characters, thus obey
|
|
font family.
|
|
|
|
See also the variable `ps-font-info-database'.")
|
|
|
|
(defconst ps-mule-font-info-database-latin
|
|
'((latin-iso8859-1
|
|
(normal nil nil iso-latin-1)))
|
|
"Sample setting of `ps-mule-font-info-database' to use latin fonts.")
|
|
|
|
(defcustom ps-mule-font-info-database-default
|
|
ps-mule-font-info-database-latin
|
|
"*The default setting to use when `ps-multibyte-buffer' is nil."
|
|
:type '(symbol :tag "Multi-Byte Buffer Database Font Default")
|
|
:group 'ps-print-font)
|
|
|
|
(defconst ps-mule-font-info-database-ps
|
|
'((katakana-jisx0201
|
|
(normal builtin "Ryumin-Light.Katakana" ps-mule-encode-7bit 1)
|
|
(bold builtin "GothicBBB-Medium.Katakana" ps-mule-encode-7bit 1)
|
|
(bold-italic builtin "GothicBBB-Medium.Katakana" ps-mule-encode-7bit 1))
|
|
(latin-jisx0201
|
|
(normal builtin "Ryumin-Light.Hankaku" ps-mule-encode-7bit 1)
|
|
(bold builtin "GothicBBB-Medium.Hankaku" ps-mule-encode-7bit 1))
|
|
(japanese-jisx0208
|
|
(normal builtin "Ryumin-Light-H" ps-mule-encode-7bit 2)
|
|
(bold builtin "GothicBBB-Medium-H" ps-mule-encode-7bit 2))
|
|
(korean-ksc5601
|
|
(normal builtin "Munhwa-Regular-KSC-EUC-H" ps-mule-encode-7bit 2)
|
|
(bold builtin "Munhwa-Bold-KSC-EUC-H" ps-mule-encode-7bit 2))
|
|
)
|
|
"Sample setting of the `ps-mule-font-info-database' to use builtin PS font.
|
|
|
|
Currently, data for Japanese and Korean PostScript printers are listed.")
|
|
|
|
(defconst ps-mule-font-info-database-bdf
|
|
'((ascii
|
|
(normal bdf ("lt1-24-etl.bdf" "etl24-latin1.bdf") nil 1)
|
|
(bold bdf ("lt1-16b-etl.bdf" "etl16b-latin1.bdf") nil 1)
|
|
(italic bdf ("lt1-16i-etl.bdf" "etl16i-latin1.bdf") nil 1)
|
|
(bold-italic bdf ("lt1-16bi-etl.bdf" "etl16bi-latin1.bdf") nil 1))
|
|
(latin-iso8859-1
|
|
(normal bdf ("lt1-24-etl.bdf" "etl24-latin1.bdf") iso-latin-1 1)
|
|
(bold bdf ("lt1-16b-etl.bdf" "etl16b-latin1.bdf") iso-latin-1 1)
|
|
(italic bdf ("lt1-16i-etl.bdf" "etl16i-latin1.bdf") iso-latin-1 1)
|
|
(bold-italic bdf ("lt1-16bi-etl.bdf" "etl16bi-latin1.bdf") iso-latin-1 1))
|
|
(latin-iso8859-2
|
|
(normal bdf ("lt2-24-etl.bdf" "etl24-latin2.bdf") iso-latin-2 1))
|
|
(latin-iso8859-3
|
|
(normal bdf ("lt3-24-etl.bdf" "etl24-latin3.bdf") iso-latin-3 1))
|
|
(latin-iso8859-4
|
|
(normal bdf ("lt4-24-etl.bdf" "etl24-latin4.bdf") iso-latin-4 1))
|
|
(thai-tis620
|
|
(normal bdf ("thai24.bdf" "thai-24.bdf") thai-tis620 1))
|
|
(greek-iso8859-7
|
|
(normal bdf ("grk24-etl.bdf" "etl24-greek.bdf") greek-iso-8bit 1))
|
|
;; (arabic-iso8859-6 nil) ; not yet available
|
|
(hebrew-iso8859-8
|
|
(normal bdf ("heb24-etl.bdf" "etl24-hebrew.bdf") hebrew-iso-8bit 1))
|
|
(katakana-jisx0201
|
|
(normal bdf "12x24rk.bdf" ps-mule-encode-8bit 1))
|
|
(latin-jisx0201
|
|
(normal bdf "12x24rk.bdf" ps-mule-encode-7bit 1))
|
|
(cyrillic-iso8859-5
|
|
(normal bdf ("cyr24-etl.bdf" "etl24-cyrillic.bdf") cyrillic-iso-8bit 1))
|
|
(latin-iso8859-9
|
|
(normal bdf ("lt5-24-etl.bdf" "etl24-latin5.bdf") iso-latin-5 1))
|
|
(japanese-jisx0208-1978
|
|
(normal bdf "jiskan24.bdf" ps-mule-encode-7bit 2))
|
|
(chinese-gb2312
|
|
(normal bdf "gb24st.bdf" ps-mule-encode-7bit 2))
|
|
(japanese-jisx0208
|
|
(normal bdf "jiskan24.bdf" ps-mule-encode-7bit 2))
|
|
(korean-ksc5601
|
|
(normal bdf "hanglm24.bdf" ps-mule-encode-7bit 2))
|
|
(japanese-jisx0212
|
|
(normal bdf ("jksp40.bdf" "jisksp40.bdf") ps-mule-encode-7bit 2))
|
|
(chinese-cns11643-1
|
|
(normal bdf ("cns1-40.bdf" "cns-1-40.bdf") ps-mule-encode-7bit 2))
|
|
(chinese-cns11643-2
|
|
(normal bdf ("cns2-40.bdf" "cns-2-40.bdf") ps-mule-encode-7bit 2))
|
|
(chinese-big5-1
|
|
(normal bdf "taipei24.bdf" chinese-big5 2))
|
|
(chinese-big5-2
|
|
(normal bdf "taipei24.bdf" chinese-big5 2))
|
|
(chinese-sisheng
|
|
(normal bdf ("sish24-etl.bdf" "etl24-sisheng.bdf") ps-mule-encode-7bit 1))
|
|
(ipa
|
|
(normal bdf ("ipa24-etl.bdf" "etl24-ipa.bdf") ps-mule-encode-8bit 1))
|
|
(vietnamese-viscii-lower
|
|
(normal bdf ("visc24-etl.bdf" "etl24-viscii.bdf") vietnamese-viscii 1))
|
|
(vietnamese-viscii-upper
|
|
(normal bdf ("visc24-etl.bdf" "etl24-viscii.bdf") vietnamese-viscii 1))
|
|
(arabic-digit
|
|
(normal bdf ("arab24-0-etl.bdf" "etl24-arabic0.bdf") ps-mule-encode-7bit 1))
|
|
(arabic-1-column
|
|
(normal bdf ("arab24-1-etl.bdf" "etl24-arabic1.bdf") ps-mule-encode-7bit 1))
|
|
;; (ascii-right-to-left nil) ; not yet available
|
|
(lao
|
|
(normal bdf ("lao24-mule.bdf" "mule-lao-24.bdf") lao 1))
|
|
(arabic-2-column
|
|
(normal bdf ("arab24-2-etl.bdf" "etl24-arabic2.bdf") ps-mule-encode-7bit 1))
|
|
(indian-is13194
|
|
(normal bdf ("isci24-mule.bdf" "mule-iscii-24.bdf") ps-mule-encode-7bit 1))
|
|
(indian-1-column
|
|
(normal bdf ("ind1c24-mule.bdf" "mule-indian-1col-24.bdf") ps-mule-encode-7bit 2))
|
|
(tibetan-1-column
|
|
(normal bdf ("tib1c24-mule.bdf" "mule-tibmdx-1col-24.bdf") ps-mule-encode-7bit 2))
|
|
(ethiopic
|
|
(normal bdf ("ethio24f-uni.bdf" "ethiomx24f-uni.bdf") ps-mule-encode-ethiopic 2))
|
|
(chinese-cns11643-3
|
|
(normal bdf ("cns3-40.bdf" "cns-3-40.bdf") ps-mule-encode-7bit 2))
|
|
(chinese-cns11643-4
|
|
(normal bdf ("cns4-40.bdf" "cns-4-40.bdf") ps-mule-encode-7bit 2))
|
|
(chinese-cns11643-5
|
|
(normal bdf ("cns5-40.bdf" "cns-5-40.bdf") ps-mule-encode-7bit 2))
|
|
(chinese-cns11643-6
|
|
(normal bdf ("cns6-40.bdf" "cns-6-40.bdf") ps-mule-encode-7bit 2))
|
|
(chinese-cns11643-7
|
|
(normal bdf ("cns7-40.bdf" "cns-7-40.bdf") ps-mule-encode-7bit 2))
|
|
(indian-2-column
|
|
(normal bdf ("ind24-mule.bdf" "mule-indian-24.bdf") ps-mule-encode-7bit 2))
|
|
(tibetan
|
|
(normal bdf ("tib24p-mule.bdf" "tib24-mule.bdf" "mule-tibmdx-24.bdf")
|
|
ps-mule-encode-7bit 2))
|
|
(mule-unicode-0100-24ff
|
|
(normal bdf "etl24-unicode.bdf" ps-mule-encode-ucs2 2))
|
|
(mule-unicode-2500-33ff
|
|
(normal bdf "etl24-unicode.bdf" ps-mule-encode-ucs2 2))
|
|
(mule-unicode-e000-ffff
|
|
(normal bdf "etl24-unicode.bdf" ps-mule-encode-ucs2 2)))
|
|
"Sample setting of the `ps-mule-font-info-database' to use BDF fonts.
|
|
BDF (Bitmap Distribution Format) is a format used for distributing X's font
|
|
source file.
|
|
|
|
Current default value list for BDF fonts is included in `intlfonts-1.2'
|
|
which is a collection of X11 fonts for all characters supported by Emacs.
|
|
|
|
Using this list as default value to `ps-mule-font-info-database', all
|
|
characters including ASCII and Latin-1 are printed by BDF fonts.
|
|
|
|
See also `ps-mule-font-info-database-ps-bdf'.")
|
|
|
|
(defconst ps-mule-font-info-database-ps-bdf
|
|
(cons (car ps-mule-font-info-database-latin)
|
|
(cdr (cdr ps-mule-font-info-database-bdf)))
|
|
"Sample setting of the `ps-mule-font-info-database' to use BDF fonts.
|
|
|
|
Current default value list for BDF fonts is included in `intlfonts-1.2'
|
|
which is a collection of X11 fonts for all characters supported by Emacs.
|
|
|
|
Using this list as default value to `ps-mule-font-info-database', all
|
|
characters except ASCII and Latin-1 characters are printed with BDF fonts.
|
|
ASCII and Latin-1 characters are printed with PostScript font specified
|
|
by `ps-font-family' and `ps-header-font-family'.
|
|
|
|
See also `ps-mule-font-info-database-bdf'.")
|
|
|
|
;; Two typical encoding functions for PostScript fonts.
|
|
|
|
(defun ps-mule-encode-7bit (string)
|
|
(ps-mule-encode-bit string 0))
|
|
|
|
(defun ps-mule-encode-8bit (string)
|
|
(ps-mule-encode-bit string 128))
|
|
|
|
(defun ps-mule-encode-bit (string delta)
|
|
(let* ((dim (charset-dimension (char-charset (string-to-char string))))
|
|
(len (* (length string) dim))
|
|
(str (make-string len 0))
|
|
(i 0)
|
|
(j 0))
|
|
(if (= dim 1)
|
|
(while (< j len)
|
|
(aset str j
|
|
(+ (nth 1 (split-char (aref string i))) delta))
|
|
(setq i (1+ i)
|
|
j (1+ j)))
|
|
(while (< j len)
|
|
(let ((split (split-char (aref string i))))
|
|
(aset str j (+ (nth 1 split) delta))
|
|
(aset str (1+ j) (+ (nth 2 split) delta))
|
|
(setq i (1+ i)
|
|
j (+ j 2)))))
|
|
str))
|
|
|
|
;; Special encoding function for Ethiopic.
|
|
(if (boundp 'mule-version) ; only if mule package is loaded
|
|
(define-ccl-program ccl-encode-ethio-unicode
|
|
`(1
|
|
((read r2)
|
|
(loop
|
|
(if (r2 == ,leading-code-private-22)
|
|
((read r0)
|
|
(if (r0 == ,(charset-id 'ethiopic))
|
|
((read r1 r2)
|
|
(r1 &= 127) (r2 &= 127)
|
|
(call ccl-encode-ethio-font)
|
|
(write r1)
|
|
(write-read-repeat r2))
|
|
((write r2 r0)
|
|
(repeat))))
|
|
(write-read-repeat r2))))))
|
|
;; to avoid compilation gripes
|
|
(defvar ccl-encode-ethio-unicode nil))
|
|
|
|
(if (boundp 'mule-version)
|
|
;; bound mule-version
|
|
(defun ps-mule-encode-ethiopic (string)
|
|
(ccl-execute-on-string (symbol-value 'ccl-encode-ethio-unicode)
|
|
(make-vector 9 nil)
|
|
string))
|
|
;; unbound mule-version
|
|
(defun ps-mule-encode-ethiopic (string)
|
|
string))
|
|
|
|
;; Special encoding for mule-unicode-* characters.
|
|
(defun ps-mule-encode-ucs2 (string)
|
|
(let* ((len (length string))
|
|
(str (make-string (* 2 len) 0))
|
|
(i 0)
|
|
(j 0)
|
|
ch hi lo)
|
|
(while (< i len)
|
|
(setq ch (encode-char (aref string i) 'ucs)
|
|
hi (lsh ch -8)
|
|
lo (logand ch 255))
|
|
(aset str j hi)
|
|
(aset str (1+ j) lo)
|
|
(setq i (1+ i)
|
|
j (+ j 2)))
|
|
str))
|
|
|
|
;; A charset which we are now processing.
|
|
(defvar ps-mule-current-charset nil)
|
|
|
|
(defun ps-mule-get-font-spec (charset font-type)
|
|
"Return FONT-SPEC for printing characters CHARSET with FONT-TYPE.
|
|
FONT-SPEC is a list that has the form:
|
|
|
|
(FONT-SRC FONT-NAME ENCODING BYTES)
|
|
|
|
FONT-SPEC is extracted from `ps-mule-font-info-database'.
|
|
|
|
See the documentation of `ps-mule-font-info-database' for the meaning of each
|
|
element of the list."
|
|
(let ((slot (cdr (assq charset ps-mule-font-info-database))))
|
|
(and slot
|
|
(cdr (or (assq font-type slot)
|
|
(and (eq font-type 'bold-italic)
|
|
(or (assq 'bold slot) (assq 'italic slot)))
|
|
(assq 'normal slot))))))
|
|
|
|
;; Functions to access each element of FONT-SPEC.
|
|
(defsubst ps-mule-font-spec-src (font-spec) (car font-spec))
|
|
(defsubst ps-mule-font-spec-name (font-spec) (nth 1 font-spec))
|
|
(defsubst ps-mule-font-spec-encoding (font-spec) (nth 2 font-spec))
|
|
(defsubst ps-mule-font-spec-bytes (font-spec) (nth 3 font-spec))
|
|
|
|
(defsubst ps-mule-printable-p (charset)
|
|
"Non-nil if characters in CHARSET is printable."
|
|
;; ASCII and Latin-1 are always printable.
|
|
(or (eq charset 'ascii)
|
|
(eq charset 'latin-iso8859-1)
|
|
(ps-mule-get-font-spec charset 'normal)))
|
|
|
|
(defconst ps-mule-external-libraries
|
|
'((builtin nil nil
|
|
nil nil nil)
|
|
(bdf ps-bdf nil
|
|
bdf-generate-prologue bdf-generate-font bdf-generate-glyphs)
|
|
(pcf nil nil
|
|
pcf-generate-prologue pcf-generate-font pcf-generate-glyphs)
|
|
(vflib nil nil
|
|
vflib-generate-prologue vflib-generate-font vflib-generate-glyphs))
|
|
"Alist of information of external libraries to support PostScript printing.
|
|
Each element has the form:
|
|
|
|
(FONT-SRC FEATURE INITIALIZED-P PROLOGUE-FUNC FONT-FUNC GLYPHS-FUNC)
|
|
|
|
FONT-SRC is the font source: builtin, bdf, pcf, or vflib.
|
|
|
|
FEATURE is the feature that provide a facility to handle FONT-SRC. Except for
|
|
`builtin' FONT-SRC, this feature is automatically `require'd before handling
|
|
FONT-SRC. Currently, we only have the feature `ps-bdf'.
|
|
|
|
INITIALIZED-P indicates if this library is initialized or not.
|
|
|
|
PROLOGUE-FUNC is a function to generate PostScript code which define several
|
|
PostScript procedures that will be called by FONT-FUNC and GLYPHS-FUNC. It is
|
|
called with no argument, and should return a list of strings.
|
|
|
|
FONT-FUNC is a function to generate PostScript code which define a new font. It
|
|
is called with one argument FONT-SPEC, and should return a list of strings.
|
|
|
|
GLYPHS-FUNC is a function to generate PostScript code which define glyphs of
|
|
characters. It is called with three arguments FONT-SPEC, CODE-LIST, and BYTES,
|
|
and should return a list of strings.")
|
|
|
|
(defun ps-mule-init-external-library (font-spec)
|
|
"Initialize external library specified by FONT-SPEC for PostScript printing.
|
|
See the documentation of `ps-mule-get-font-spec' for FONT-SPEC's meaning."
|
|
(let* ((font-src (ps-mule-font-spec-src font-spec))
|
|
(slot (assq font-src ps-mule-external-libraries)))
|
|
(or (not font-src)
|
|
(nth 2 slot)
|
|
(let ((func (nth 3 slot)))
|
|
(if func
|
|
(progn
|
|
(require (nth 1 slot))
|
|
(ps-output-prologue (funcall func))))
|
|
(setcar (nthcdr 2 slot) t)))))
|
|
|
|
;; Cached glyph information of fonts, alist of:
|
|
;; (FONT-NAME ((FONT-TYPE-NUMBER . SCALED-FONT-NAME) ...)
|
|
;; cache CODE0 CODE1 ...)
|
|
(defvar ps-mule-font-cache nil)
|
|
|
|
(defun ps-mule-generate-font (font-spec charset &optional header-p)
|
|
"Generate PostScript codes to define a new font in FONT-SPEC for CHARSET.
|
|
|
|
If optional 3rd arg HEADER-P is non-nil, generate codes to define a header
|
|
font."
|
|
(let* ((font-name (ps-mule-font-spec-name font-spec))
|
|
(font-name (if (consp font-name) (car font-name) font-name))
|
|
(font-cache (assoc font-name ps-mule-font-cache))
|
|
(font-src (ps-mule-font-spec-src font-spec))
|
|
(func (nth 4 (assq font-src ps-mule-external-libraries)))
|
|
(font-size (if header-p (if (eq ps-current-font 0)
|
|
ps-header-title-font-size-internal
|
|
ps-header-font-size-internal)
|
|
ps-font-size-internal))
|
|
(current-font (+ ps-current-font (if header-p 10 0)))
|
|
(scaled-font-name
|
|
(cond (header-p
|
|
(format "h%d" ps-current-font))
|
|
((eq charset 'ascii)
|
|
(format "f%d" ps-current-font))
|
|
(t
|
|
(format "f%02x-%d" (charset-id charset) ps-current-font)))))
|
|
(and func (not font-cache)
|
|
(ps-output-prologue (funcall func charset font-spec)))
|
|
(ps-output-prologue
|
|
(list (format "/%s %f /%s Def%sFontMule\n"
|
|
scaled-font-name font-size font-name
|
|
(if (or header-p
|
|
(eq ps-mule-current-charset 'ascii))
|
|
"Ascii" ""))))
|
|
(if font-cache
|
|
(setcar (cdr font-cache)
|
|
(cons (cons current-font scaled-font-name)
|
|
(nth 1 font-cache)))
|
|
(setq font-cache (list font-name
|
|
(list (cons current-font scaled-font-name))
|
|
'cache)
|
|
ps-mule-font-cache (cons font-cache ps-mule-font-cache)))
|
|
font-cache))
|
|
|
|
(defun ps-mule-generate-glyphs (font-spec code-list)
|
|
"Generate PostScript codes which generate glyphs for CODE-LIST of FONT-SPEC."
|
|
(let* ((font-src (ps-mule-font-spec-src font-spec))
|
|
(func (nth 5 (assq font-src ps-mule-external-libraries))))
|
|
(and func
|
|
(ps-output-prologue
|
|
(funcall func font-spec code-list
|
|
(ps-mule-font-spec-bytes font-spec))))))
|
|
|
|
(defun ps-mule-prepare-font (font-spec string charset
|
|
&optional no-setfont header-p)
|
|
"Generate PostScript codes to print STRING of CHARSET by font FONT-SPEC.
|
|
|
|
The generated code is inserted on prologue part except the code that sets the
|
|
current font (using PostScript procedure `FM').
|
|
|
|
If optional 4th arg NO-SETFONT is non-nil, don't generate the code for setting
|
|
the current font.
|
|
|
|
If optional 5th arg HEADER-P is non-nil, generate a code for setting a header
|
|
font."
|
|
(let* ((font-name (ps-mule-font-spec-name font-spec))
|
|
(font-name (if (consp font-name) (car font-name) font-name))
|
|
(current-font (+ ps-current-font (if header-p 10 0)))
|
|
(font-cache (assoc font-name ps-mule-font-cache)))
|
|
(or (and font-cache (assq current-font (nth 1 font-cache)))
|
|
(setq font-cache (ps-mule-generate-font font-spec charset header-p)))
|
|
(or no-setfont
|
|
(let ((new-font (cdr (assq current-font (nth 1 font-cache)))))
|
|
(or (equal new-font ps-last-font)
|
|
(progn
|
|
(ps-output (format "/%s FM\n" new-font))
|
|
(setq ps-last-font new-font)))))
|
|
(if (nth 5 (assq (ps-mule-font-spec-src font-spec)
|
|
ps-mule-external-libraries))
|
|
;; We have to generate PostScript codes which define glyphs.
|
|
(let* ((cached-codes (nthcdr 2 font-cache))
|
|
(bytes (ps-mule-font-spec-bytes font-spec))
|
|
(len (length string))
|
|
(i 0)
|
|
newcodes code)
|
|
(while (< i len)
|
|
(setq code (if (= bytes 1)
|
|
(aref string i)
|
|
(+ (* (aref string i) 256) (aref string (1+ i)))))
|
|
(or (memq code cached-codes)
|
|
(progn
|
|
(setq newcodes (cons code newcodes))
|
|
(setcdr cached-codes (cons code (cdr cached-codes)))))
|
|
(setq i (+ i bytes)))
|
|
(and newcodes
|
|
(ps-mule-generate-glyphs font-spec newcodes))))))
|
|
|
|
;;;###autoload
|
|
(defun ps-mule-prepare-ascii-font (string)
|
|
"Setup special ASCII font for STRING.
|
|
STRING should contain only ASCII characters."
|
|
(let ((font-spec
|
|
(ps-mule-get-font-spec
|
|
'ascii
|
|
(car (nth ps-current-font (ps-font-alist 'ps-font-for-text))))))
|
|
(and font-spec
|
|
(ps-mule-prepare-font font-spec string 'ascii))))
|
|
|
|
;;;###autoload
|
|
(defun ps-mule-set-ascii-font ()
|
|
(unless (eq ps-mule-current-charset 'ascii)
|
|
(ps-set-font ps-current-font)
|
|
(setq ps-mule-current-charset 'ascii)))
|
|
|
|
;; List of charsets of multi-byte characters in a text being printed.
|
|
;; If the text doesn't contain any multi-byte characters (i.e. only ASCII),
|
|
;; the value is nil.
|
|
(defvar ps-mule-charset-list nil)
|
|
|
|
;; This is a PostScript code inserted in the header of generated PostScript.
|
|
(defconst ps-mule-prologue
|
|
"%%%% Start of Mule Section
|
|
|
|
%% Working dictionary for general use.
|
|
/MuleDict 10 dict def
|
|
|
|
%% Adjust /RelativeCompose properly by checking /BaselineOffset.
|
|
/AdjustRelativeCompose { % fontdict |- fontdict
|
|
dup length 2 add dict begin
|
|
{ 1 index /FID ne { def } { pop pop } ifelse } forall
|
|
currentdict /BaselineOffset known {
|
|
BaselineOffset false eq { /BaselineOffset 0 def } if
|
|
} {
|
|
/BaselineOffset 0 def
|
|
} ifelse
|
|
currentdict /RelativeCompose known not {
|
|
/RelativeCompose [ 0 0.1 ] def
|
|
} {
|
|
RelativeCompose false ne {
|
|
[ BaselineOffset RelativeCompose BaselineOffset add
|
|
[ FontMatrix { FontSize div } forall ] transform ]
|
|
/RelativeCompose exch def
|
|
} if
|
|
} ifelse
|
|
currentdict
|
|
end
|
|
} def
|
|
|
|
%% Define already scaled font for non-ASCII character sets.
|
|
/DefFontMule { % fontname size basefont |- --
|
|
findfont exch scalefont AdjustRelativeCompose definefont pop
|
|
} bind def
|
|
|
|
%% Define already scaled font for ASCII character sets.
|
|
/DefAsciiFontMule { % fontname size basefont |-
|
|
MuleDict begin
|
|
findfont dup /Encoding get /ISOLatin1Encoding exch def
|
|
exch scalefont AdjustRelativeCompose reencodeFontISO
|
|
end
|
|
} def
|
|
|
|
/CurrentFont false def
|
|
|
|
%% Set the specified font to use.
|
|
%% For non-ASCII font, don't install Ascent, etc.
|
|
/FM { % fontname |- --
|
|
/font exch def
|
|
font /f0 eq font /f1 eq font /f2 eq font /f3 eq or or or {
|
|
font F
|
|
} {
|
|
font findfont setfont
|
|
} ifelse
|
|
} bind def
|
|
|
|
%% Show vacant box for characters which don't have appropriate font.
|
|
/SB { % count column |- --
|
|
SpaceWidth mul /w exch def
|
|
1 exch 1 exch { %for
|
|
pop
|
|
gsave
|
|
0 setlinewidth
|
|
0 Descent rmoveto w 0 rlineto
|
|
0 LineHeight rlineto w neg 0 rlineto closepath stroke
|
|
grestore
|
|
w 0 rmoveto
|
|
} for
|
|
} bind def
|
|
|
|
%% Flag to tell if we are now handling a composition. This is
|
|
%% defined here because both composition handler and bitmap font
|
|
%% handler require it.
|
|
/Composing false def
|
|
|
|
%%%% End of Mule Section
|
|
|
|
"
|
|
"PostScript code for printing multi-byte characters.")
|
|
|
|
(defvar ps-mule-prologue-generated nil)
|
|
|
|
(defun ps-mule-prologue-generated ()
|
|
(unless ps-mule-prologue-generated
|
|
(ps-output-prologue ps-mule-prologue)
|
|
(setq ps-mule-prologue-generated t)))
|
|
|
|
(defun ps-mule-find-wrappoint (from to char-width &optional composition)
|
|
"Find the longest sequence which is printable in the current line.
|
|
|
|
The search starts at FROM and goes until TO.
|
|
|
|
Optional 4th arg COMPOSITION, if non-nil, is information of
|
|
composition starting at FROM.
|
|
|
|
If COMPOSITION is nil, it is assumed that all characters between FROM
|
|
and TO belong to a charset in `ps-mule-current-charset'. Otherwise,
|
|
it is assumed that all characters between FROM and TO belong to the
|
|
same composition.
|
|
|
|
CHAR-WIDTH is the average width of ASCII characters in the current font.
|
|
|
|
Returns the value:
|
|
|
|
(ENDPOS . RUN-WIDTH)
|
|
|
|
Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
|
|
the sequence."
|
|
(if (or composition (eq ps-mule-current-charset 'composition))
|
|
;; We must draw one char by one.
|
|
(let ((run-width (if composition
|
|
(nth 5 composition)
|
|
(* (char-width (char-after from)) char-width))))
|
|
(if (> run-width ps-width-remaining)
|
|
(cons from ps-width-remaining)
|
|
(cons (if composition
|
|
(nth 1 composition)
|
|
(1+ from))
|
|
run-width)))
|
|
;; We assume that all characters in this range have the same width.
|
|
(setq char-width (* char-width (charset-width ps-mule-current-charset)))
|
|
(let ((run-width (* (abs (- from to)) char-width)))
|
|
(if (> run-width ps-width-remaining)
|
|
(cons (min to
|
|
(save-excursion
|
|
(goto-char from)
|
|
(forward-point
|
|
(truncate (/ ps-width-remaining char-width)))))
|
|
ps-width-remaining)
|
|
(cons to run-width)))))
|
|
|
|
;;;###autoload
|
|
(defun ps-mule-plot-string (from to &optional bg-color)
|
|
"Generate PostScript code for plotting characters in the region FROM and TO.
|
|
|
|
It is assumed that all characters in this region belong to the same charset.
|
|
|
|
Optional argument BG-COLOR specifies background color.
|
|
|
|
Returns the value:
|
|
|
|
(ENDPOS . RUN-WIDTH)
|
|
|
|
Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
|
|
the sequence."
|
|
(let ((ch (char-after from)))
|
|
(setq ps-mule-current-charset
|
|
(char-charset (or (aref ps-print-translation-table ch) ch))))
|
|
(let* ((wrappoint (ps-mule-find-wrappoint
|
|
from to (ps-avg-char-width 'ps-font-for-text)))
|
|
(to (car wrappoint))
|
|
(font-type (car (nth ps-current-font
|
|
(ps-font-alist 'ps-font-for-text))))
|
|
(font-spec (ps-mule-get-font-spec ps-mule-current-charset font-type))
|
|
(string (buffer-substring-no-properties from to)))
|
|
(dotimes (i (length string))
|
|
(let ((ch (aref ps-print-translation-table (aref string i))))
|
|
(if ch
|
|
(aset string i ch))))
|
|
(cond
|
|
((= from to)
|
|
;; We can't print any more characters in the current line.
|
|
nil)
|
|
|
|
(font-spec
|
|
;; We surely have a font for printing this character set.
|
|
(ps-output-string (ps-mule-string-encoding font-spec string))
|
|
(ps-output " S\n"))
|
|
|
|
((eq ps-mule-current-charset 'latin-iso8859-1)
|
|
;; Latin-1 can be printed by a normal ASCII font.
|
|
(ps-output-string (ps-mule-string-ascii string))
|
|
(ps-output " S\n"))
|
|
|
|
;; This case is obsolete for Emacs 21.
|
|
((eq ps-mule-current-charset 'composition)
|
|
(ps-mule-plot-composition from (1+ from) bg-color))
|
|
|
|
(t
|
|
;; No way to print this charset. Just show a vacant box of an
|
|
;; appropriate width.
|
|
(ps-output (format "%d %d SB\n"
|
|
(length string)
|
|
(if (eq ps-mule-current-charset 'composition)
|
|
(char-width (char-after from))
|
|
(charset-width ps-mule-current-charset))))))
|
|
wrappoint))
|
|
|
|
;;;###autoload
|
|
(defun ps-mule-plot-composition (from to &optional bg-color)
|
|
"Generate PostScript code for plotting composition in the region FROM and TO.
|
|
|
|
It is assumed that all characters in this region belong to the same
|
|
composition.
|
|
|
|
Optional argument BG-COLOR specifies background color.
|
|
|
|
Returns the value:
|
|
|
|
(ENDPOS . RUN-WIDTH)
|
|
|
|
Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
|
|
the sequence."
|
|
(let* ((composition (find-composition from nil nil t))
|
|
(wrappoint (ps-mule-find-wrappoint
|
|
from to (ps-avg-char-width 'ps-font-for-text)
|
|
composition))
|
|
(to (car wrappoint))
|
|
(font-type (car (nth ps-current-font
|
|
(ps-font-alist 'ps-font-for-text)))))
|
|
(if (< from to)
|
|
;; We can print this composition in the current line.
|
|
(let ((components (nth 2 composition)))
|
|
(ps-mule-plot-components
|
|
(ps-mule-prepare-font-for-components components font-type)
|
|
(if (nth 3 composition) "RLC" "RBC"))))
|
|
wrappoint))
|
|
|
|
;; Prepare font of FONT-TYPE for printing COMPONENTS. By side effect,
|
|
;; change character elements in COMPONENTS to the form:
|
|
;; ENCODED-STRING or (FONTNAME . ENCODED-STRING)
|
|
;; and change rule elements to the encoded value (integer).
|
|
;; The latter form is used if we much change font for the character.
|
|
|
|
(defun ps-mule-prepare-font-for-components (components font-type)
|
|
(let ((len (length components))
|
|
(i 0)
|
|
elt)
|
|
(while (< i len)
|
|
(setq elt (aref components i))
|
|
(if (consp elt)
|
|
;; ELT is a composition rule.
|
|
(setq elt (encode-composition-rule elt))
|
|
;; ELT is a glyph character.
|
|
(let* ((charset (char-charset elt))
|
|
(font (or (eq charset ps-mule-current-charset)
|
|
(if (eq charset 'ascii)
|
|
(format "/f%d" ps-current-font)
|
|
(format "/f%02x-%d"
|
|
(charset-id charset) ps-current-font))))
|
|
str)
|
|
(setq ps-mule-current-charset charset
|
|
str (ps-mule-string-encoding
|
|
(ps-mule-get-font-spec charset font-type)
|
|
(char-to-string elt)
|
|
'no-setfont))
|
|
(if (stringp font)
|
|
(setq elt (cons font str) ps-last-font font)
|
|
(setq elt str))))
|
|
(aset components i elt)
|
|
(setq i (1+ i))))
|
|
components)
|
|
|
|
(defun ps-mule-plot-components (components tail)
|
|
(let ((elt (aref components 0))
|
|
(len (length components))
|
|
(i 1))
|
|
(ps-output "[ ")
|
|
(if (stringp elt)
|
|
(ps-output-string elt)
|
|
(ps-output (car elt) " ")
|
|
(ps-output-string (cdr elt)))
|
|
(while (< i len)
|
|
(setq elt (aref components i) i (1+ i))
|
|
(ps-output " ")
|
|
(cond ((stringp elt)
|
|
(ps-output-string elt))
|
|
((consp elt)
|
|
(ps-output (car elt) " ")
|
|
(ps-output-string (cdr elt)))
|
|
(t ; i.e. (integerp elt)
|
|
(ps-output (format "%d" elt)))))
|
|
(ps-output " ] " tail "\n")))
|
|
|
|
;; Composite font support
|
|
|
|
(defvar ps-mule-composition-prologue-generated nil)
|
|
|
|
(defconst ps-mule-composition-prologue
|
|
"%%%% Character composition handler
|
|
/RelativeCompositionSkip 0.4 def
|
|
|
|
%% Get a bounding box (relative to currentpoint) of STR.
|
|
/GetPathBox { % str |- --
|
|
gsave
|
|
currentfont /FontType get 3 eq { %ifelse
|
|
stringwidth pop pop
|
|
} {
|
|
currentpoint /y exch def /x exch def
|
|
false charpath flattenpath pathbbox
|
|
y sub /URY exch def x sub /URX exch def
|
|
y sub /LLY exch def x sub /LLX exch def
|
|
} ifelse
|
|
grestore
|
|
} bind def
|
|
|
|
%% Apply effects (underline, strikeout, overline, box) to the
|
|
%% rectangle specified by TOP BOTTOM LEFT RIGHT.
|
|
/SpecialEffect { % -- |- --
|
|
currentpoint dup TOP add /yy exch def BOTTOM add /YY exch def
|
|
dup LEFT add /xx exch def RIGHT add /XX exch def
|
|
%% Adjust positions for future shadowing.
|
|
Effect 8 and 0 ne {
|
|
/yy yy Yshadow add def
|
|
/XX XX Xshadow add def
|
|
} if
|
|
Effect 1 and 0 ne { UnderlinePosition Hline } if % underline
|
|
Effect 2 and 0 ne { StrikeoutPosition Hline } if % strikeout
|
|
Effect 4 and 0 ne { OverlinePosition Hline } if % overline
|
|
bg { % background
|
|
true
|
|
Effect 16 and 0 ne {SpaceBackground doBox} { xx yy XX YY doRect} ifelse
|
|
} if
|
|
Effect 16 and 0 ne { false 0 doBox } if % box
|
|
} def
|
|
|
|
%% Show STR with effects (shadow, outline).
|
|
/ShowWithEffect { % str |- --
|
|
Effect 8 and 0 ne { dup doShadow } if
|
|
Effect 32 and 0 ne { true doOutline } { show } ifelse
|
|
} def
|
|
|
|
%% Draw COMPONENTS which have the form [ font0? [str0 xoff0 yoff0] ... ].
|
|
/ShowComponents { % components |- -
|
|
LEFT 0 lt { LEFT neg 0 rmoveto } if
|
|
{
|
|
dup type /nametype eq { % font
|
|
FM
|
|
} { % [ str xoff yoff ]
|
|
gsave
|
|
aload pop rmoveto ShowWithEffect
|
|
grestore
|
|
} ifelse
|
|
} forall
|
|
RIGHT 0 rmoveto
|
|
} def
|
|
|
|
%% Show relative composition.
|
|
/RLC { % [ font0? str0 font1? str1 ... fontN? strN ] |- --
|
|
/components exch def
|
|
/Composing true def
|
|
/first true def
|
|
gsave
|
|
[ components {
|
|
/elt exch def
|
|
elt type /nametype eq { % font
|
|
elt dup FM
|
|
} { first { % first string
|
|
/first false def
|
|
elt GetPathBox
|
|
%% Bounding box of overall glyphs.
|
|
/LEFT LLX def
|
|
/RIGHT URX def
|
|
/TOP URY def
|
|
/BOTTOM LLY def
|
|
currentfont /RelativeCompose known {
|
|
/relative currentfont /RelativeCompose get def
|
|
} {
|
|
%% Disable relative composition by setting sufficiently low
|
|
%% and high positions.
|
|
/relative [ -100000 100000 ] def
|
|
} ifelse
|
|
[ elt 0 0 ]
|
|
} { % other strings
|
|
elt GetPathBox
|
|
[ elt % str
|
|
LLX 0 lt { RIGHT } { 0 } ifelse % xoff
|
|
LLY relative 1 get ge { % compose on TOP
|
|
TOP LLY sub RelativeCompositionSkip add % yoff
|
|
/TOP TOP URY LLY sub add RelativeCompositionSkip add def
|
|
} { URY relative 0 get le { % compose under BOTTOM
|
|
BOTTOM URY sub RelativeCompositionSkip sub % yoff
|
|
/BOTTOM BOTTOM URY LLY sub sub
|
|
RelativeCompositionSkip sub def
|
|
} {
|
|
0 % yoff
|
|
URY TOP gt { /TOP URY def } if
|
|
LLY BOTTOM lt { /BOTTOM LLY def } if
|
|
} ifelse } ifelse
|
|
]
|
|
URX RIGHT gt { /RIGHT URX def } if
|
|
} ifelse } ifelse
|
|
} forall ] /components exch def
|
|
grestore
|
|
|
|
%% Reflect special effects.
|
|
SpecialEffect
|
|
|
|
%% Draw components while ignoring effects other than shadow and outline.
|
|
components ShowComponents
|
|
/Composing false def
|
|
|
|
} def
|
|
|
|
%% Show rule-base composition.
|
|
/RBC { % [ font0? str0 rule1 font1? str1 rule2 ... strN ] |- --
|
|
/components exch def
|
|
/Composing true def
|
|
/first true def
|
|
gsave
|
|
[ components {
|
|
/elt exch def
|
|
elt type /nametype eq { % font
|
|
elt dup FM
|
|
} { elt type /integertype eq { % rule
|
|
%% This RULE decoding should be compatible with macro
|
|
%% COMPOSITION_DECODE_RULE in emacs/src/composite.h.
|
|
elt 12 idiv dup 3 mod /grefx exch def 3 idiv /grefy exch def
|
|
elt 12 mod dup 3 mod /nrefx exch def 3 idiv /nrefy exch def
|
|
} { first { % first string
|
|
/first false def
|
|
elt GetPathBox
|
|
%% Bounding box of overall glyphs.
|
|
/LEFT LLX def
|
|
/RIGHT URX def
|
|
/TOP URY def
|
|
/BOTTOM LLY def
|
|
/WIDTH RIGHT LEFT sub def
|
|
[ elt 0 0 ]
|
|
} { % other strings
|
|
elt GetPathBox
|
|
/width URX LLX sub def
|
|
/height URY LLY sub def
|
|
/left LEFT [ 0 WIDTH 2 div WIDTH ] grefx get add
|
|
[ 0 width 2 div width ] nrefx get sub def
|
|
/bottom [ TOP 0 BOTTOM TOP BOTTOM add 2 div ] grefy get
|
|
[ height LLY neg 0 height 2 div ] nrefy get sub def
|
|
%% Update bounding box
|
|
left LEFT lt { /LEFT left def } if
|
|
left width add RIGHT gt { /RIGHT left width add def } if
|
|
/WIDTH RIGHT LEFT sub def
|
|
bottom BOTTOM lt { /BOTTOM bottom def } if
|
|
bottom height add TOP gt { /TOP bottom height add def } if
|
|
[ elt left LLX sub bottom LLY sub ]
|
|
} ifelse } ifelse } ifelse
|
|
} forall ] /components exch def
|
|
grestore
|
|
|
|
%% Reflect special effects.
|
|
SpecialEffect
|
|
|
|
%% Draw components while ignoring effects other than shadow and outline.
|
|
components ShowComponents
|
|
|
|
/Composing false def
|
|
} def
|
|
%%%% End of character composition handler
|
|
|
|
"
|
|
"PostScript code for printing character composition.")
|
|
|
|
(defun ps-mule-string-ascii (str)
|
|
(ps-set-font ps-current-font)
|
|
(string-as-unibyte (encode-coding-string str 'iso-latin-1)))
|
|
|
|
;; Encode STR for a font specified by FONT-SPEC and return the result.
|
|
;; If necessary, it generates the PostScript code for the font and glyphs to
|
|
;; print STR. If optional 4th arg HEADER-P is non-nil, it is assumed that STR
|
|
;; is for headers.
|
|
(defun ps-mule-string-encoding (font-spec str &optional no-setfont header-p)
|
|
(let ((encoding (ps-mule-font-spec-encoding font-spec)))
|
|
(setq str
|
|
(string-as-unibyte
|
|
(cond ((coding-system-p encoding)
|
|
(encode-coding-string str encoding))
|
|
((functionp encoding)
|
|
(funcall encoding str))
|
|
(encoding
|
|
(error "Invalid coding system or function: %s" encoding))
|
|
(t
|
|
str))))
|
|
(if (ps-mule-font-spec-src font-spec)
|
|
(ps-mule-prepare-font font-spec str ps-mule-current-charset
|
|
(or no-setfont header-p)
|
|
header-p)
|
|
(or no-setfont
|
|
(ps-set-font ps-current-font)))
|
|
str))
|
|
|
|
;; Bitmap font support
|
|
|
|
(defvar ps-mule-bitmap-prologue-generated nil)
|
|
|
|
(defconst ps-mule-bitmap-prologue
|
|
"%%%% Bitmap font handler
|
|
|
|
/str7 7 string def % working area
|
|
|
|
%% We grow the dictionary one bunch (1024 entries) by one.
|
|
/BitmapDictArray 256 array def
|
|
/BitmapDictLength 1024 def
|
|
/BitmapDictIndex -1 def
|
|
|
|
/NewBitmapDict { % -- |- --
|
|
/BitmapDictIndex BitmapDictIndex 1 add def
|
|
BitmapDictArray BitmapDictIndex BitmapDictLength dict put
|
|
} bind def
|
|
|
|
%% Make at least one dictionary.
|
|
NewBitmapDict
|
|
|
|
/AddBitmap { % gloval-charname bitmap-data |- --
|
|
BitmapDictArray BitmapDictIndex get
|
|
dup length BitmapDictLength ge {
|
|
pop
|
|
NewBitmapDict
|
|
BitmapDictArray BitmapDictIndex get
|
|
} if
|
|
3 1 roll put
|
|
} bind def
|
|
|
|
/GetBitmap { % gloval-charname |- bitmap-data
|
|
0 1 BitmapDictIndex { BitmapDictArray exch get begin } for
|
|
load
|
|
0 1 BitmapDictIndex { pop end } for
|
|
} bind def
|
|
|
|
%% Return a global character name which can be used as a key in the
|
|
%% bitmap dictionary.
|
|
/GlobalCharName { % fontidx code1 code2 |- gloval-charname
|
|
exch 256 mul add exch 65536 mul add 16777216 add 16 str7 cvrs 0 66 put
|
|
str7 cvn
|
|
} bind def
|
|
|
|
%% Character code holder for a 2-byte character.
|
|
/FirstCode -1 def
|
|
|
|
%% Glyph rendering procedure
|
|
/BuildGlyphCommon { % fontdict charname |- --
|
|
1 index /FontDimension get 1 eq { /FirstCode 0 store } if
|
|
NameIndexDict exch get % STACK: fontdict charcode
|
|
FirstCode 0 lt { %ifelse
|
|
%% This is the first byte of a 2-byte character. Just
|
|
%% remember it for the moment.
|
|
/FirstCode exch store
|
|
pop
|
|
0 0 setcharwidth
|
|
} {
|
|
1 index /FontSize get /size exch def
|
|
1 index /FontSpaceWidthRatio get /ratio exch def
|
|
1 index /FontIndex get exch FirstCode exch
|
|
GlobalCharName GetBitmap /bmp exch def
|
|
%% bmp == [ DWIDTH BBX-WIDTH BBX-HEIGHT BBX-XOFF BBX-YOFF BITMAP ]
|
|
Composing { %ifelse
|
|
/FontMatrix get [ exch { size div } forall ] /mtrx exch def
|
|
bmp 3 get bmp 4 get mtrx transform
|
|
/LLY exch def /LLX exch def
|
|
bmp 1 get bmp 3 get add bmp 2 get bmp 4 get add mtrx transform
|
|
/URY exch def /URX exch def
|
|
} {
|
|
pop
|
|
} ifelse
|
|
/FirstCode -1 store
|
|
|
|
bmp 0 get SpaceWidthRatio ratio div mul size div 0 % wx wy
|
|
setcharwidth % We can't use setcachedevice here.
|
|
|
|
bmp 1 get 0 gt bmp 2 get 0 gt and {
|
|
bmp 1 get bmp 2 get % width height
|
|
true % polarity
|
|
[ size 0 0 size neg bmp 3 get neg bmp 2 get bmp 4 get add ] % matrix
|
|
bmp 5 1 getinterval cvx % datasrc
|
|
imagemask
|
|
} if
|
|
} ifelse
|
|
} bind def
|
|
|
|
/BuildCharCommon {
|
|
1 index /Encoding get exch get
|
|
1 index /BuildGlyph get exec
|
|
} bind def
|
|
|
|
%% Bitmap font creator
|
|
|
|
%% Common Encoding shared by all bitmap fonts.
|
|
/EncodingCommon 256 array def
|
|
%% Mapping table from character name to character code.
|
|
/NameIndexDict 256 dict def
|
|
0 1 255 { %for
|
|
/idx exch def
|
|
/idxname idx 256 add 16 (XXX) cvrs dup 0 67 put cvn def % `C' == 67
|
|
EncodingCommon idx idxname put
|
|
NameIndexDict idxname idx put
|
|
} for
|
|
|
|
/GlobalFontIndex 0 def
|
|
|
|
%% fontname dim col fontsize relative-compose baseline-offset fbbx |- --
|
|
/BitmapFont {
|
|
15 dict begin
|
|
/FontBBox exch def
|
|
/BaselineOffset exch def
|
|
/RelativeCompose exch def
|
|
/FontSize exch def
|
|
/FontBBox [ FontBBox { FontSize div } forall ] def
|
|
FontBBox 2 get FontBBox 0 get sub exch div
|
|
/FontSpaceWidthRatio exch def
|
|
/FontDimension exch def
|
|
/FontIndex GlobalFontIndex def
|
|
/FontType 3 def
|
|
/FontMatrix matrix def
|
|
/Encoding EncodingCommon def
|
|
/BuildGlyph { BuildGlyphCommon } def
|
|
/BuildChar { BuildCharCommon } def
|
|
currentdict end
|
|
definefont pop
|
|
/GlobalFontIndex GlobalFontIndex 1 add def
|
|
} bind def
|
|
|
|
%% Define a new bitmap font.
|
|
%% fontname dim col fontsize relative-compose baseline-offset fbbx |- --
|
|
/NF {
|
|
/fbbx exch def
|
|
%% Convert BDF's FontBoundingBox to PostScript's FontBBox
|
|
[ fbbx 2 get fbbx 3 get
|
|
fbbx 2 get fbbx 0 get add fbbx 3 get fbbx 1 get add ]
|
|
BitmapFont
|
|
} bind def
|
|
|
|
%% Define a glyph for the specified font and character.
|
|
/NG { % fontname charcode bitmap-data |- --
|
|
/bmp exch def
|
|
exch findfont dup /BaselineOffset get bmp 4 get add bmp exch 4 exch put
|
|
/FontIndex get exch
|
|
dup 256 idiv exch 256 mod GlobalCharName
|
|
bmp AddBitmap
|
|
} bind def
|
|
%%%% End of bitmap font handler
|
|
|
|
")
|
|
|
|
;; External library support.
|
|
|
|
;; The following three functions are to be called from external
|
|
;; libraries which support bitmap fonts (e.g. `bdf') to get
|
|
;; appropriate PostScript code.
|
|
|
|
(defun ps-mule-generate-bitmap-prologue ()
|
|
(unless ps-mule-bitmap-prologue-generated
|
|
(setq ps-mule-bitmap-prologue-generated t)
|
|
(list ps-mule-bitmap-prologue)))
|
|
|
|
(defun ps-mule-generate-bitmap-font (&rest args)
|
|
(list (apply 'format "/%s %d %d %f %S %d %S NF\n" args)))
|
|
|
|
(defun ps-mule-generate-bitmap-glyph (font-name code dwidth bbx bitmap)
|
|
(format "/%s %d [ %d %d %d %d %d <%s> ] NG\n"
|
|
font-name code
|
|
dwidth (aref bbx 0) (aref bbx 1) (aref bbx 2) (aref bbx 3)
|
|
bitmap))
|
|
|
|
;; Mule specific initializers.
|
|
|
|
;;;###autoload
|
|
(defun ps-mule-initialize ()
|
|
"Initialize global data for printing multi-byte characters."
|
|
(setq ps-mule-font-cache nil
|
|
ps-mule-prologue-generated nil
|
|
ps-mule-composition-prologue-generated nil
|
|
ps-mule-bitmap-prologue-generated nil)
|
|
(mapcar `(lambda (x) (setcar (nthcdr 2 x) nil))
|
|
ps-mule-external-libraries))
|
|
|
|
(defvar ps-mule-header-charsets nil)
|
|
|
|
;;;###autoload
|
|
(defun ps-mule-encode-header-string (string fonttag)
|
|
"Generate PostScript code for ploting STRING by font FONTTAG.
|
|
FONTTAG should be a string \"/h0\" or \"/h1\"."
|
|
(setq string (cond ((not (stringp string))
|
|
"")
|
|
((multibyte-string-p string)
|
|
(copy-sequence string))
|
|
(t
|
|
(string-make-multibyte string))))
|
|
(when ps-mule-header-charsets
|
|
(if (eq (car ps-mule-header-charsets) 'latin-iso8859-1)
|
|
;; Latin1 characters can be printed by the standard PostScript
|
|
;; font. Converts the other non-ASCII characters to `?'.
|
|
(let ((len (length string))
|
|
(i 0))
|
|
(while (< i len)
|
|
(or (memq (char-charset (aref string i)) '(ascii latin-iso8859-1))
|
|
(aset string i ??))
|
|
(setq i (1+ i)))
|
|
(setq string (encode-coding-string string 'iso-latin-1)))
|
|
;; We must prepare a font for the first non-ASCII and non-Latin1
|
|
;; character in STRING.
|
|
(let* ((ps-current-font (if (string= fonttag "/h0") 0 1))
|
|
(ps-mule-current-charset (car ps-mule-header-charsets))
|
|
(font-type (car (nth ps-current-font
|
|
(ps-font-alist 'ps-font-for-header))))
|
|
(font-spec (ps-mule-get-font-spec ps-mule-current-charset
|
|
font-type)))
|
|
(if (or (not font-spec)
|
|
(/= (charset-dimension ps-mule-current-charset) 1))
|
|
;; We don't have a proper font, or we can't print them on
|
|
;; header because this kind of charset is not ASCII
|
|
;; compatible.
|
|
(let ((len (length string))
|
|
(i 0))
|
|
(while (< i len)
|
|
(or (memq (char-charset (aref string i))
|
|
'(ascii latin-iso8859-1))
|
|
(aset string i ??))
|
|
(setq i (1+ i)))
|
|
(setq string (encode-coding-string string 'iso-latin-1)))
|
|
(let ((charsets (list 'ascii (car ps-mule-header-charsets)))
|
|
(len (length string))
|
|
(i 0))
|
|
(while (< i len)
|
|
(or (memq (char-charset (aref string i)) charsets)
|
|
(aset string i ??))
|
|
(setq i (1+ i))))
|
|
(setq string (ps-mule-string-encoding font-spec string nil t))))))
|
|
string)
|
|
|
|
(defun ps-mule-show-warning (charsets from to header-footer-list)
|
|
(let ((table (make-category-table))
|
|
(buf (current-buffer))
|
|
(max-unprintable-chars 15)
|
|
char-pos-list)
|
|
(define-category ?u "Unprintable charset" table)
|
|
(dolist (cs charsets)
|
|
(modify-category-entry (make-char cs) ?u table))
|
|
(with-category-table table
|
|
(save-excursion
|
|
(goto-char from)
|
|
(while (and (<= (length char-pos-list) max-unprintable-chars)
|
|
(re-search-forward "\\cu" to t))
|
|
(push (cons (preceding-char) (1- (point))) char-pos-list))))
|
|
(with-output-to-temp-buffer "*Warning*"
|
|
(with-current-buffer standard-output
|
|
(when char-pos-list
|
|
(let ((func #'(lambda (buf pos)
|
|
(when (buffer-live-p buf)
|
|
(pop-to-buffer buf)
|
|
(goto-char pos))))
|
|
(more nil))
|
|
(if (>= (length char-pos-list) max-unprintable-chars)
|
|
(setq char-pos-list (cdr char-pos-list)
|
|
more t))
|
|
(insert "These characters in the buffer can't be printed:\n")
|
|
(dolist (elt (nreverse char-pos-list))
|
|
(insert " ")
|
|
(insert-text-button (string (car elt))
|
|
:type 'help-xref
|
|
'help-echo
|
|
"mouse-2, RET: jump to this character"
|
|
'help-function func
|
|
'help-args (list buf (cdr elt)))
|
|
(insert ","))
|
|
(if more
|
|
(insert " and more...")
|
|
;; Delete the last comma.
|
|
(delete-char -1))
|
|
(insert "\nClick them to jump to the buffer position,\n"
|
|
(substitute-command-keys "\
|
|
or \\[universal-argument] \\[what-cursor-position] will give information about them.\n"))))
|
|
|
|
(with-category-table table
|
|
(let (string-list idx)
|
|
(dolist (elt header-footer-list)
|
|
(when (stringp elt)
|
|
(when (string-match "\\cu+" elt)
|
|
(setq elt (copy-sequence elt))
|
|
(put-text-property (match-beginning 0) (match-end 0)
|
|
'face 'highlight elt)
|
|
(while (string-match "\\cu+" elt (match-end 0))
|
|
(put-text-property (match-beginning 0) (match-end 0)
|
|
'face 'highlight elt))
|
|
(push elt string-list))))
|
|
(when string-list
|
|
(insert
|
|
"These highlighted characters in header/footer can't be printed:\n")
|
|
(dolist (elt string-list)
|
|
(insert " " elt "\n")))))))))
|
|
|
|
;;;###autoload
|
|
(defun ps-mule-begin-job (from to)
|
|
"Start printing job for multi-byte chars between FROM and TO.
|
|
This checks if all multi-byte characters in the region are printable or not."
|
|
(setq ps-mule-charset-list nil
|
|
ps-mule-header-charsets nil
|
|
ps-mule-font-info-database
|
|
(cond ((eq ps-multibyte-buffer 'non-latin-printer)
|
|
ps-mule-font-info-database-ps)
|
|
((eq ps-multibyte-buffer 'bdf-font)
|
|
ps-mule-font-info-database-bdf)
|
|
((eq ps-multibyte-buffer 'bdf-font-except-latin)
|
|
ps-mule-font-info-database-ps-bdf)
|
|
(t
|
|
ps-mule-font-info-database-default)))
|
|
(and (boundp 'enable-multibyte-characters)
|
|
enable-multibyte-characters
|
|
;; Initialize `ps-mule-charset-list'. If some characters aren't
|
|
;; printable, warn it.
|
|
(let ((header-footer-list (ps-header-footer-string))
|
|
unprintable-charsets)
|
|
(setq ps-mule-charset-list
|
|
(delq 'ascii (delq 'eight-bit-control
|
|
(delq 'eight-bit-graphic
|
|
(find-charset-region
|
|
from to ps-print-translation-table))))
|
|
ps-mule-header-charsets
|
|
(delq 'ascii (delq 'eight-bit-control
|
|
(delq 'eight-bit-graphic
|
|
(find-charset-string
|
|
(mapconcat
|
|
'identity header-footer-list "")
|
|
ps-print-translation-table)))))
|
|
(dolist (cs ps-mule-charset-list)
|
|
(or (ps-mule-printable-p cs)
|
|
(push cs unprintable-charsets)))
|
|
(dolist (cs ps-mule-header-charsets)
|
|
(or (ps-mule-printable-p cs)
|
|
(memq cs unprintable-charsets)
|
|
(push cs unprintable-charsets)))
|
|
(when unprintable-charsets
|
|
(ps-mule-show-warning unprintable-charsets from to
|
|
header-footer-list)
|
|
(or
|
|
(y-or-n-p "Font for some characters not found, continue anyway? ")
|
|
(error "Printing cancelled")))
|
|
|
|
(or ps-mule-composition-prologue-generated
|
|
(let ((use-composition (nth 2 (find-composition from to))))
|
|
(or use-composition
|
|
(let (str)
|
|
(while header-footer-list
|
|
(setq str (car header-footer-list))
|
|
(if (and (stringp str)
|
|
(nth 2 (find-composition 0 (length str) str)))
|
|
(setq use-composition t
|
|
header-footer-list nil)
|
|
(setq header-footer-list (cdr header-footer-list))))))
|
|
(when use-composition
|
|
(progn
|
|
(ps-mule-prologue-generated)
|
|
(ps-output-prologue ps-mule-composition-prologue)
|
|
(setq ps-mule-composition-prologue-generated t)))))))
|
|
|
|
(setq ps-mule-current-charset 'ascii)
|
|
|
|
(if (or ps-mule-charset-list ps-mule-header-charsets)
|
|
(dolist (elt (append ps-mule-header-charsets ps-mule-charset-list))
|
|
(ps-mule-prologue-generated)
|
|
(ps-mule-init-external-library (ps-mule-get-font-spec elt 'normal))))
|
|
|
|
;; If ASCII font is also specified in ps-mule-font-info-database,
|
|
;; use it instead of what specified in ps-font-info-database.
|
|
(let ((font-spec (ps-mule-get-font-spec 'ascii 'normal)))
|
|
(if font-spec
|
|
(progn
|
|
(ps-mule-prologue-generated)
|
|
(ps-mule-init-external-library font-spec)
|
|
(let ((font (ps-font-alist 'ps-font-for-text))
|
|
(ps-current-font 0))
|
|
(while font
|
|
;; Be sure to download a glyph for SPACE in advance.
|
|
(ps-mule-prepare-font (ps-mule-get-font-spec 'ascii (car font))
|
|
" " 'ascii 'no-setfont)
|
|
(setq font (cdr font)
|
|
ps-current-font (1+ ps-current-font)))))))
|
|
|
|
;; If the header contains non-ASCII and non-Latin1 characters, prepare a font
|
|
;; and glyphs for the first occurrence of such characters.
|
|
(if (and ps-mule-header-charsets
|
|
(not (eq (car ps-mule-header-charsets) 'latin-iso8859-1))
|
|
(= (charset-dimension (car ps-mule-header-charsets)) 1))
|
|
(let ((font-spec (ps-mule-get-font-spec (car ps-mule-header-charsets)
|
|
'normal)))
|
|
(if font-spec
|
|
;; Be sure to download glyphs for "0123456789/" in advance for page
|
|
;; numbering.
|
|
(let ((ps-current-font 0))
|
|
(ps-mule-prepare-font font-spec "0123456789/" 'ascii t t)))))
|
|
|
|
(if ps-mule-charset-list
|
|
;; We must change this regexp for multi-byte buffer.
|
|
(setq ps-control-or-escape-regexp
|
|
(cond ((eq ps-print-control-characters '8-bit)
|
|
"[^\040-\176]")
|
|
((eq ps-print-control-characters 'control-8-bit)
|
|
(string-as-multibyte "[^\040-\176\240-\377]"))
|
|
((eq ps-print-control-characters 'control)
|
|
(string-as-multibyte "[^\040-\176\200-\377]"))
|
|
(t (string-as-multibyte "[^\000-\011\013\015-\377]"))))))
|
|
|
|
;;;###autoload
|
|
(defun ps-mule-begin-page ()
|
|
(setq ps-mule-current-charset 'ascii))
|
|
|
|
|
|
(provide 'ps-mule)
|
|
|
|
;;; arch-tag: bca017b2-66a7-4e59-8584-103e749eadbe
|
|
;;; ps-mule.el ends here
|