From 2cb842aeec54fc9234f62fbc3b35cd99ef0a3776 Mon Sep 17 00:00:00 2001 From: Kenichi Handa Date: Tue, 15 Dec 1998 06:38:12 +0000 Subject: [PATCH] New file. Mule related code extracted from ps-print.el. Require ps-print, provide ps-mule. (ps-multibyte-buffer): Add autoload cookie. (ps-mule-prepare-ascii-font): New fun. (ps-mule-set-ascii-font): New fun. (ps-mule-skip-same-charset): Fun deleted. (ps-mule-plot-string): Set ps-mule-current-charset. (ps-mule-initialize): Add autload cookie. Don't set ps-mule-font-info-database here. (ps-mule-begin-job): Renamed from ps-mule-begin. Update ps-mule-font-info-database and ps-control-or-escape-regexp. (ps-mule-begin-page): New fun. Doc fix. Require ps-print only when compiled. (ps-mule-prologue-generated): New fun. (ps-mule-plot-string): Add autoload cookie. (ps-mule-begin-job): Call ps-mule-prologue-generated. Programming uniformization and little code improvement. (ps-mule-prepare-font): Programming uniformization. (ps-mule-find-wrappoint, ps-mule-plot-rule-cmpchar) (ps-mule-string-encoding, ps-mule-begin-job): Little code improvement. Always require ps-print. Move some function definitions for Emacs 20.2 and the earlier to ps-print.el. (ps-mule-find-wrappoint): Make it work also with Emacs 20.2. (ps-mule-begin-job): Delete nil and unknown from a list of character sets found by find-charset-region. --- lisp/ps-mule.el | 1156 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1156 insertions(+) diff --git a/lisp/ps-mule.el b/lisp/ps-mule.el index e69de29bb2d..49dac6b89fb 100644 --- a/lisp/ps-mule.el +++ b/lisp/ps-mule.el @@ -0,0 +1,1156 @@ +;;; ps-mule.el --- Provide multi-byte character facility to ps-print. + +;; Copyright (C) 1998 Free Software Foundation, Inc. + +;; Author: Vinicius Jose Latorre +;; Author: Kenichi Handa (multi-byte characters) +;; Maintainer: Kenichi Handa (multi-byte characters) +;; Maintainer: Vinicius Jose Latorre +;; Keywords: print, PostScript, multibyte, mule +;; Time-stamp: <98/12/15 14:04:50 handa> + +;; 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 when you are printing +;; buffer with only ASCII and Latin characters. +;; +;; `non-latin-printer' This is the value to use when you have a japanese +;; or korean PostScript printer and want to print +;; buffer with ASCII, Latin-1, Japanese (JISX0208 and +;; JISX0201-Kana) and Korean characters. At present, +;; it was not tested the Korean characters printing. +;; If you have a korean PostScript printer, please, +;; test it. +;; +;; `bdf-font' This is the value to use when you want to print +;; buffer with BDF fonts. BDF fonts include both latin +;; and non-latin fonts. BDF (Bitmap Distribution +;; Format) is a format used for distributing X's font +;; source file. BDF fonts are included in +;; `intlfonts-1.1' which is a collection of X11 fonts +;; for all characters supported by Emacs. In order to +;; use this value, be sure to have installed +;; `intlfonts-1.1' and set the variable +;; `bdf-directory-list' appropriately (see 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)) + +;;;###autoload +(defcustom ps-multibyte-buffer nil + "*Specifies the multi-byte buffer handling. + +Valid values are: + + nil This is the value to use when you are printing + buffer with only ASCII and Latin characters. + + `non-latin-printer' This is the value to use when you have a japanese + or korean PostScript printer and want to print + buffer with ASCII, Latin-1, Japanese (JISX0208 and + JISX0201-Kana) and Korean characters. At present, + it was not tested the Korean characters printing. + If you have a korean PostScript printer, please, + test it. + + `bdf-font' This is the value to use when you want to print + buffer with BDF fonts. BDF fonts include both latin + and non-latin fonts. BDF (Bitmap Distribution + Format) is a format used for distributing X's font + source file. BDF fonts are included in + `intlfonts-1.1' which is a collection of X11 fonts + for all characters supported by Emacs. In order to + use this value, be sure to have installed + `intlfonts-1.1' and set the variable + `bdf-directory-list' appropriately (see 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) (other :tag "nil" nil)) + :group 'ps-print-font) + +;; For Emacs 20.2 and the earlier version. +(eval-and-compile + (if (not (string< mule-version "4.0")) + (progn + (defalias 'ps-mule-next-point '1+) + (defalias 'ps-mule-chars-in-string 'length) + (defalias 'ps-mule-string-char 'aref) + (defsubst ps-mule-next-index (str i) (1+ i))) + (defun ps-mule-next-point (arg) + (save-excursion (goto-char arg) (forward-char 1) (point))) + (defun ps-mule-chars-in-string (string) + (/ (length string) + (charset-bytes (char-charset (string-to-char string))))) + (defun ps-mule-string-char (string idx) + (string-to-char (substring string idx))) + (defun ps-mule-next-index (string i) + (+ i (charset-bytes (char-charset (string-to-char string)))))) + ) + +(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, ps-bdf, vflib, or nil. + + If FONT-SRC is builtin, FONT-NAME is a buitin PostScript font name. + + If FONT-SRC is bdf, FONT-NAME is a BDF font file name. To use this font, + the external library `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.") + +(defconst ps-mule-font-info-database-ps + '((katakana-jisx0201 + (normal builtin "Ryumin-Light.Katakana" ps-mule-encode-7bit 1) + (bold builtin "GothicBBB-Medium.Katakana" ps-mule-encode-7bit 1) + (bold-italic builtin "GothicBBB-Medium.Katakana" ps-mule-encode-7bit 1)) + (latin-jisx0201 + (normat builtin "Ryumin-Light.Hankaku" ps-mule-encode-7bit 1) + (bold builtin "GothicBBB-Medium.Hankaku" ps-mule-encode-7bit 1)) + (japanese-jisx0208 + (normal builtin "Ryumin-Light-H" ps-mule-encode-7bit 2) + (bold builtin "GothicBBB-Medium-H" ps-mule-encode-7bit 2)) + (korean-ksc5601 + (normal builtin "Batang-Medium-KSC-H" ps-mule-encode-7bit 2) + (bold builtin " Gulim-Medium-KSC-H" ps-mule-encode-7bit 2)) + ) + "Sample setting of the `ps-mule-font-info-database' to use builtin PS font. + +Currently, data for Japanese and Korean PostScript printers are listed.") + +(defconst ps-mule-font-info-database-bdf + '((ascii + (normal bdf "etl24-latin1.bdf" nil 1) + (bold bdf "etl16b-latin1.bdf" iso-latin-1 1) + (italic bdf "etl16i-latin1.bdf" iso-latin-1 1) + (bold-italic bdf "etl16bi-latin1.bdf" iso-latin-1 1)) + (latin-iso8859-1 + (normal bdf "etl24-latin1.bdf" iso-latin-1 1) + (bold bdf "etl16b-latin1.bdf" iso-latin-1 1) + (italic bdf "etl16i-latin1.bdf" iso-latin-1 1) + (bold-italic bdf "etl16bi-latin1.bdf" iso-latin-1 1)) + (latin-iso8859-2 + (normal bdf "etl24-latin2.bdf" iso-latin-2 1)) + (latin-iso8859-3 + (normal bdf "etl24-latin3.bdf" iso-latin-3 1)) + (latin-iso8859-4 + (normal bdf "etl24-latin4.bdf" iso-latin-4 1)) + (thai-tis620 + (normal bdf "thai-24.bdf" thai-tis620 1)) + (greek-iso8859-7 + (normal bdf "etl24-greek.bdf" greek-iso-8bit 1)) + ;; (arabic-iso8859-6 nil) ; not yet available + (hebrew-iso8859-8 + (normal bdf "etl24-hebrew.bdf" hebrew-iso-8bit 1)) + (katakana-jisx0201 + (normal bdf "12x24rk.bdf" ps-mule-encode-8bit 1)) + (latin-jisx0201 + (normal bdf "12x24rk.bdf" ps-mule-encode-7bit 1)) + (cyrillic-iso8859-5 + (normal bdf "etl24-cyrillic.bdf" cyrillic-iso-8bit 1)) + (latin-iso8859-9 + (normal bdf "etl24-latin5.bdf" iso-latin-5 1)) + (japanese-jisx0208-1978 + (normal bdf "jiskan24.bdf" ps-mule-encode-7bit 2)) + (chinese-gb2312 + (normal bdf "gb24st.bdf" ps-mule-encode-7bit 2)) + (japanese-jisx0208 + (normal bdf "jiskan24.bdf" ps-mule-encode-7bit 2)) + (korean-ksc5601 + (normal bdf "hanglm24.bdf" ps-mule-encode-7bit 2)) + (japanese-jisx0212 + (normal bdf "jisksp40.bdf" ps-mule-encode-7bit 2)) + (chinese-cns11643-1 + (normal bdf "cns-1-40.bdf" ps-mule-encode-7bit 2)) + (chinese-cns11643-2 + (normal bdf "cns-2-40.bdf" ps-mule-encode-7bit 2)) + (chinese-big5-1 + (normal bdf "taipei24.bdf" chinese-big5 2)) + (chinese-big5-2 + (normal bdf "taipei24.bdf" chinese-big5 2)) + (chinese-sisheng + (normal bdf "etl24-sisheng.bdf" ps-mule-encode-8bit 1)) + (ipa + (normal bdf "etl24-ipa.bdf" ps-mule-encode-8bit 1)) + (vietnamese-viscii-lower + (normal bdf "etl24-viscii.bdf" vietnamese-viscii 1)) + (vietnamese-viscii-upper + (normal bdf "etl24-viscii.bdf" vietnamese-viscii 1)) + (arabic-digit + (normal bdf "etl24-arabic0.bdf" ps-mule-encode-7bit 1)) + (arabic-1-column + (normal bdf "etl24-arabic1.bdf" ps-mule-encode-7bit 1)) + ;; (ascii-right-to-left nil) ; not yet available + (lao + (normal bdf "mule-lao-24.bdf" lao 1)) + (arabic-2-column + (normal bdf "etl24-arabic2.bdf" ps-mule-encode-7bit 1)) + (indian-is13194 + (normal bdf "mule-iscii-24.bdf" ps-mule-encode-7bit 1)) + (indian-1-column + (normal bdf "mule-indian-1col-24.bdf" ps-mule-encode-7bit 2)) + (tibetan-1-column + (normal bdf "mule-tibmdx-1col-24.bdf" ps-mule-encode-7bit 2)) + (ethiopic + (normal bdf "ethiomx24f-uni.bdf" ps-mule-encode-ethiopic 2)) + (chinese-cns11643-3 + (normal bdf "cns-3-40.bdf" ps-mule-encode-7bit 2)) + (chinese-cns11643-4 + (normal bdf "cns-4-40.bdf" ps-mule-encode-7bit 2)) + (chinese-cns11643-5 + (normal bdf "cns-5-40.bdf" ps-mule-encode-7bit 2)) + (chinese-cns11643-6 + (normal bdf "cns-6-40.bdf" ps-mule-encode-7bit 2)) + (chinese-cns11643-7 + (normal bdf "cns-7-40.bdf" ps-mule-encode-7bit 2)) + (indian-2-column + (normal bdf "mule-indian-24.bdf" ps-mule-encode-7bit 2)) + (tibetan + (normal bdf "mule-tibmdx-24.bdf" ps-mule-encode-7bit 2))) + "Sample setting of the `ps-mule-font-info-database' to use BDF fonts. +BDF (Bitmap Distribution Format) is a format used for distributing X's font +source file. + +Current default value list for BDF fonts is included in `intlfonts-1.1' which is +a collection of X11 fonts for all characters supported by Emacs. + +Using this list as default value to `ps-mule-font-info-database', all characters +including ASCII and Latin-1 are printed by BDF fonts. + +See also `ps-mule-font-info-database-ps-bdf'.") + +(defconst ps-mule-font-info-database-ps-bdf + (cons (car ps-mule-font-info-database-latin) + (cdr (cdr ps-mule-font-info-database-bdf))) + "Sample setting of the `ps-mule-font-info-database' to use BDF fonts. + +Current default value list for BDF fonts is included in `intlfonts-1.1' which is +a collection of X11 fonts for all characters supported by Emacs. + +Using this list as default value to `ps-mule-font-info-database', all characters +except ASCII and Latin-1 characters are printed by BDF fonts. ASCII and Latin-1 +characters are printed by PostScript font specified by `ps-font-family' and +`ps-header-font-family'. + +See also `ps-mule-font-info-database-bdf'.") + +;; Two typical encoding functions for PostScript fonts. + +(defun ps-mule-encode-7bit (string) + (ps-mule-encode-bit string 0)) + +(defun ps-mule-encode-8bit (string) + (ps-mule-encode-bit string 128)) + +(defun ps-mule-encode-bit (string delta) + (let* ((dim (charset-dimension (char-charset (string-to-char string)))) + (len (* (ps-mule-chars-in-string string) dim)) + (str (make-string len 0)) + (i 0) + (j 0)) + (if (= dim 1) + (while (< j len) + (aset str j + (+ (nth 1 (split-char (ps-mule-string-char string i))) delta)) + (setq i (ps-mule-next-index string i) + j (1+ j))) + (while (< j len) + (let ((split (split-char (ps-mule-string-char string i)))) + (aset str j (+ (nth 1 split) delta)) + (aset str (1+ j) (+ (nth 2 split) delta)) + (setq i (ps-mule-next-index string i) + j (+ j 2))))) + str)) + +;; Special encoding function for Ethiopic. +(define-ccl-program ccl-encode-ethio-unicode + `(1 + ((read r2) + (loop + (if (r2 == ,leading-code-private-22) + ((read r0) + (if (r0 == ,(charset-id 'ethiopic)) + ((read r1 r2) + (r1 &= 127) (r2 &= 127) + (call ccl-encode-ethio-font) + (write r1) + (write-read-repeat r2)) + ((write r2 r0) + (repeat)))) + (write-read-repeat r2)))))) + +(defun ps-mule-encode-ethiopic (string) + (ccl-execute-on-string (symbol-value 'ccl-encode-ethio-unicode) + (make-vector 9 nil) + string)) + +;; A charset which we are now processing. +(defvar ps-mule-current-charset nil) + +(defun ps-mule-get-font-spec (charset font-type) + "Return FONT-SPEC for printing characters CHARSET with FONT-TYPE. +FONT-SPEC is a list that has the form: + + (FONT-SRC FONT-NAME ENCODING BYTES) + +FONT-SPEC is extracted from `ps-mule-font-info-database'. + +See the documentation of `ps-mule-font-info-database' for the meaning of each +element of the list." + (let ((slot (cdr (assq charset ps-mule-font-info-database)))) + (and slot + (cdr (or (assq font-type slot) + (and (eq font-type 'bold-italic) + (or (assq 'bold slot) (assq 'italic slot))) + (assq 'normal slot)))))) + +;; Functions to access each element of FONT-SPEC. +(defsubst ps-mule-font-spec-src (font-spec) (car font-spec)) +(defsubst ps-mule-font-spec-name (font-spec) (nth 1 font-spec)) +(defsubst ps-mule-font-spec-encoding (font-spec) (nth 2 font-spec)) +(defsubst ps-mule-font-spec-bytes (font-spec) (nth 3 font-spec)) + +(defsubst ps-mule-printable-p (charset) + "Non-nil if characters in CHARSET is printable." + (ps-mule-get-font-spec charset 'normal)) + +(defconst ps-mule-external-libraries + '((builtin nil nil + nil nil 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 + (or (featurep (nth 1 slot)) (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) + "Generate PostScript codes to define a new font in FONT-SPEC for CHARSET." + (let* ((font-cache (assoc (ps-mule-font-spec-name font-spec) + ps-mule-font-cache)) + (font-src (ps-mule-font-spec-src font-spec)) + (font-name (ps-mule-font-spec-name font-spec)) + (func (nth 4 (assq font-src ps-mule-external-libraries))) + (scaled-font-name + (if (eq charset 'ascii) + (format "f%d" ps-current-font) + (format "f%02x-%d" + (charset-id charset) ps-current-font)))) + (and func (not font-cache) + (ps-output-prologue (funcall func charset font-spec))) + (ps-output-prologue + (list (format "/%s %f /%s Def%sFontMule\n" + scaled-font-name ps-font-size font-name + (if (eq ps-mule-current-charset 'ascii) "Ascii" "")))) + (if font-cache + (setcar (cdr font-cache) + (cons (cons ps-current-font scaled-font-name) + (nth 1 font-cache))) + (setq font-cache (list font-name + (list (cons ps-current-font scaled-font-name)) + 'cache) + ps-mule-font-cache (cons font-cache ps-mule-font-cache))) + font-cache)) + +(defun ps-mule-generate-glyphs (font-spec code-list) + "Generate PostScript codes which generate glyphs for CODE-LIST of FONT-SPEC." + (let* ((font-src (ps-mule-font-spec-src font-spec)) + (func (nth 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) + "Generate PostScript codes to print STRING of CHARSET by font FONT-SPEC. + +The generated code is inserted on prologue part except the code that sets the +current font (using PostScript procedure `FM'). + +If optional arg NO-SETFONT is non-nil, don't generate the code for setting the +current font." + (let ((font-cache (assoc (ps-mule-font-spec-name font-spec) + ps-mule-font-cache))) + (or (and font-cache (assq ps-current-font (nth 1 font-cache))) + (setq font-cache (ps-mule-generate-font font-spec charset))) + (or no-setfont + (let ((new-font (cdr (assq ps-current-font (nth 1 font-cache))))) + (or (equal new-font ps-last-font) + (progn + (ps-output (format "/%s FM\n" new-font)) + (setq ps-last-font new-font))))) + (if (nth 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 + +%% Define already scaled font for non-ASCII character sets. +/DefFontMule { % fontname size basefont |- -- + findfont exch scalefont definefont pop +} bind def + +%% Define already scaled font for ASCII character sets. +/DefAsciiFontMule { % fontname size basefont |- + MuleDict begin + findfont dup /Encoding get /ISOLatin1Encoding exch def + exch scalefont reencodeFontISO + end +} def + +%% Set the specified non-ASCII font to use. It doesn't install +%% Ascent, etc. +/FM { % fontname |- -- + findfont setfont +} bind def + +%% Show vacant box for characters which don't have appropriate font. +/SB { % count column |- -- + SpaceWidth mul /w exch def + 1 exch 1 exch { %for + pop + gsave + 0 setlinewidth + 0 Descent rmoveto w 0 rlineto + 0 LineHeight rlineto w neg 0 rlineto closepath stroke + grestore + w 0 rmoveto + } for +} bind def + +%% Flag to tell if we are now handling a composite character. This is +%% defined here because both composite character handler and bitmap font +%% handler require it. +/Cmpchar false def + +%%%% End of Mule Section + +" + "PostScript code for printing multi-byte characters.") + +(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) + "Find the longest sequence which is printable in the current line. + +The search starts at FROM and goes until TO. It is assumed that all characters +between FROM and TO belong to a charset in `ps-mule-current-charset'. + +CHAR-WIDTH is the average width of ASCII characters in the current font. + +Returns the value: + + (ENDPOS . RUN-WIDTH) + +Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of +the sequence." + (if (eq ps-mule-current-charset 'composition) + ;; We must draw one char by one. + (let ((run-width (* (char-width (char-after from)) char-width))) + (if (> run-width ps-width-remaining) + (cons from ps-width-remaining) + (cons (ps-mule-next-point 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 (* (chars-in-region 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 ploting characters in the region FROM and TO. + +It is assumed that all characters in this region belong to the same charset. + +Optional argument BG-COLOR specifies background color. + +Returns the value: + + (ENDPOS . RUN-WIDTH) + +Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of +the sequence." + (setq ps-mule-current-charset (charset-after from)) + (let* ((wrappoint (ps-mule-find-wrappoint + from to (ps-avg-char-width 'ps-font-for-text))) + (to (car wrappoint)) + (font-type (car (nth ps-current-font + (ps-font-alist 'ps-font-for-text)))) + (font-spec (ps-mule-get-font-spec ps-mule-current-charset font-type)) + (string (buffer-substring-no-properties from to))) + (cond + ((= from to) + ;; We can't print any more characters in the current line. + nil) + + (font-spec + ;; We surely have a font for printing this character set. + (ps-output-string (ps-mule-string-encoding font-spec string)) + (ps-output " S\n")) + + ((eq ps-mule-current-charset 'latin-iso8859-1) + ;; Latin-1 can be printed by a normal ASCII font. + (ps-output-string (ps-mule-string-ascii string)) + (ps-output " S\n")) + + ((eq ps-mule-current-charset 'composition) + (let* ((ch (char-after from)) + (width (char-width ch)) + (ch-list (decompose-composite-char ch 'list t))) + (if (consp (nth 1 ch-list)) + (ps-mule-plot-rule-cmpchar ch-list width font-type) + (ps-mule-plot-cmpchar ch-list width t font-type)))) + + (t + ;; No way to print this charset. Just show a vacant box of an + ;; appropriate width. + (ps-output (format "%d %d SB\n" + (length string) + (if (eq ps-mule-current-charset 'composition) + (char-width (char-after from)) + (charset-width ps-mule-current-charset)))))) + wrappoint)) + +;; Composite font support + +(defvar ps-mule-cmpchar-prologue-generated nil) + +(defconst ps-mule-cmpchar-prologue + "%%%% Composite character handler +/CmpcharWidth 0 def +/CmpcharRelativeCompose 0 def +/CmpcharRelativeSkip 0.4 def + +%% Get a bounding box (relative to currentpoint) of STR. +/GetPathBox { % str |- -- + gsave + currentfont /FontType get 3 eq { %ifelse + stringwidth pop pop + } { + currentpoint /y exch def pop + false charpath flattenpath pathbbox + y sub /URY exch def pop + y sub /LLY exch def pop + } ifelse + grestore +} bind def + +%% Beginning of composite char. +/BC { % str xoff width |- -- + /Cmpchar true def + /CmpcharWidth exch def + currentfont /RelativeCompose known { + /CmpcharRelativeCompose currentfont /RelativeCompose get def + } { + /CmpcharRelativeCompose false def + } ifelse + /bgsave bg def /bgcolorsave bgcolor def + /Effectsave Effect def + gsave % Reflect effect only at first + /Effect Effect 1 2 add 4 add 16 add and def + /f0 findfont setfont ( ) 0 CmpcharWidth getinterval S + grestore + /Effect Effectsave 8 32 add and def % enable only shadow and outline + false BG + gsave SpaceWidth mul 0 rmoveto dup GetPathBox S grestore + /y currentpoint exch pop def + /HIGH URY y add def /LOW LLY y add def +} bind def + +%% End of composite char. +/EC { % -- |- -- + /bg bgsave def /bgcolor bgcolorsave def + /Effect Effectsave def + /Cmpchar false def + CmpcharWidth SpaceWidth mul 0 rmoveto +} bind def + +%% Rule base composition +/RBC { % str xoff gref nref |- -- + /nref exch def /gref exch def + gsave + SpaceWidth mul 0 rmoveto + dup + GetPathBox + [ HIGH currentpoint exch pop LOW HIGH LOW add 2 div ] gref get + [ URY LLY sub LLY neg 0 URY LLY sub 2 div ] nref get + sub /btm exch def + /top btm URY LLY sub add def + top HIGH gt { /HIGH top def } if + btm LOW lt { /LOW btm def } if + currentpoint pop btm LLY sub moveto + S + grestore +} bind def + +%% Relative composition +/RLC { % str |- -- + gsave + dup GetPathBox + CmpcharRelativeCompose type /integertype eq { + LLY CmpcharRelativeCompose gt { % compose on top + currentpoint pop HIGH LLY sub CmpcharRelativeSkip add moveto + /HIGH HIGH URY LLY sub add CmpcharRelativeSkip add def + } { URY 0 le { % compose under bottom + currentpoint pop LOW LLY add CmpcharRelativeSkip sub moveto + /LOW LOW URY LLY sub sub CmpcharRelativeSkip sub def + } if } ifelse } if + S + grestore +} bind def +%%%% End of composite character handler + +" + "PostScript code for printing composite characters.") + +(defun ps-mule-plot-rule-cmpchar (ch-rule-list total-width font-type) + (let ((leftmost 0.0) + (rightmost (float (char-width (car ch-rule-list)))) + (the-list (cons '(3 . 3) ch-rule-list)) + cmpchar-elements) + (while the-list + (let* ((this (car the-list)) + (gref (car this)) + (nref (cdr this)) + ;; X-axis info (0:left, 1:center, 2:right) + (gref-x (% gref 3)) + (nref-x (% nref 3)) + ;; Y-axis info (0:top, 1:base, 2:bottom, 3:center) + (gref-y (if (= gref 4) 3 (/ gref 3))) + (nref-y (if (= nref 4) 3 (/ nref 3))) + (char (car (cdr the-list))) + (width (float (char-width char))) + left) + (setq left (+ leftmost + (* (- rightmost leftmost) gref-x 0.5) + (- (* nref-x width 0.5))) + cmpchar-elements (cons (list char left gref-y nref-y) + cmpchar-elements) + leftmost (min left leftmost) + rightmost (max (+ left width) rightmost) + the-list (nthcdr 2 the-list)))) + (if (< leftmost 0) + (let ((the-list cmpchar-elements) + elt) + (while the-list + (setq elt (car the-list) + the-list (cdr the-list)) + (setcar (cdr elt) (- (nth 1 elt) leftmost))))) + (ps-mule-plot-cmpchar (nreverse cmpchar-elements) + total-width nil font-type))) + +(defun ps-mule-plot-cmpchar (elements total-width relativep font-type) + (let* ((elt (car elements)) + (ch (if relativep elt (car elt)))) + (ps-output-string (ps-mule-prepare-cmpchar-font ch font-type)) + (ps-output (format " %d %d BC " + (if relativep 0 (nth 1 elt)) + total-width)) + (while (setq elements (cdr elements)) + (setq elt (car elements) + ch (if relativep elt (car elt))) + (ps-output-string (ps-mule-prepare-cmpchar-font ch font-type)) + (ps-output (if relativep + " RLC " + (format " %d %d %d RBC " + (nth 1 elt) (nth 2 elt) (nth 3 elt)))))) + (ps-output "EC\n")) + +(defun ps-mule-prepare-cmpchar-font (char font-type) + (let* ((ps-mule-current-charset (char-charset char)) + (font-spec (ps-mule-get-font-spec ps-mule-current-charset font-type))) + (cond (font-spec + (ps-mule-string-encoding font-spec (char-to-string char))) + + ((eq ps-mule-current-charset 'latin-iso8859-1) + (ps-mule-string-ascii (char-to-string char))) + + (t + ;; No font for CHAR. + (ps-set-font ps-current-font) + " ")))) + +(defun ps-mule-string-ascii (str) + (ps-set-font ps-current-font) + (string-as-unibyte (encode-coding-string str 'iso-latin-1))) + +(defun ps-mule-string-encoding (font-spec str) + (let ((encoding (ps-mule-font-spec-encoding font-spec))) + (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) + (ps-set-font ps-current-font)) + str)) + +;; Bitmap font support + +(defvar ps-mule-bitmap-prologue-generated nil) + +(defconst ps-mule-bitmap-prologue + "%%%% Bitmap font handler + +/str7 7 string def % working area + +%% We grow the dictionary one bunch (1024 entries) by one. +/BitmapDictArray 256 array def +/BitmapDictLength 1024 def +/BitmapDictIndex -1 def + +/NewBitmapDict { % -- |- -- + /BitmapDictIndex BitmapDictIndex 1 add def + BitmapDictArray BitmapDictIndex BitmapDictLength dict put +} bind def + +%% Make at least one dictionary. +NewBitmapDict + +/AddBitmap { % gloval-charname bitmap-data |- -- + BitmapDictArray BitmapDictIndex get + dup length BitmapDictLength ge { + pop + NewBitmapDict + BitmapDictArray BitmapDictIndex get + } if + 3 1 roll put +} bind def + +/GetBitmap { % gloval-charname |- bitmap-data + 0 1 BitmapDictIndex { BitmapDictArray exch get begin } for + load + 0 1 BitmapDictIndex { pop end } for +} bind def + +%% Return a global character name which can be used as a key in the +%% bitmap dictionary. +/GlobalCharName { % fontidx code1 code2 |- gloval-charname + exch 256 mul add exch 65536 mul add 16777216 add 16 str7 cvrs 0 66 put + str7 cvn +} bind def + +%% Character code holder for a 2-byte character. +/FirstCode -1 def + +%% Glyph rendering procedure +/BuildGlyphCommon { % fontdict charname |- -- + 1 index /FontDimension get 1 eq { /FirstCode 0 store } if + NameIndexDict exch get % STACK: fontdict charcode + FirstCode 0 lt { %ifelse + %% This is the first byte of a 2-byte character. Just + %% remember it for the moment. + /FirstCode exch store + pop + 0 0 setcharwidth + } { + 1 index /FontSize get /size exch def + 1 index /FontSpaceWidthRatio get /ratio exch def + 1 index /FontIndex get exch FirstCode exch + GlobalCharName GetBitmap /bmp exch def + %% bmp == [ DWIDTH BBX-WIDTH BBX-HEIGHT BBX-XOFF BBX-YOFF BITMAP ] + Cmpchar { %ifelse + /FontMatrix get [ exch { size div } forall ] /mtrx exch def + bmp 3 get bmp 4 get mtrx transform + /LLY exch def pop + bmp 1 get bmp 3 get add bmp 2 get bmp 4 get add mtrx transform + /URY exch def pop + } { + pop + } ifelse + /FirstCode -1 store + + bmp 0 get SpaceWidthRatio ratio div mul size div 0 % wx wy + setcharwidth % We can't use setcachedevice here. + + bmp 1 get 0 gt bmp 2 get 0 gt and { + bmp 1 get bmp 2 get % width height + true % polarity + [ size 0 0 size neg bmp 3 get neg bmp 2 get bmp 4 get add ] % matrix + bmp 5 1 getinterval cvx % datasrc + imagemask + } if + } ifelse +} bind def + +/BuildCharCommon { + 1 index /Encoding get exch get + 1 index /BuildGlyph get exec +} bind def + +%% Bitmap font creater + +%% Common Encoding shared by all bitmap fonts. +/EncodingCommon 256 array def +%% Mapping table from character name to character code. +/NameIndexDict 256 dict def +0 1 255 { %for + /idx exch def + /idxname idx 256 add 16 (XXX) cvrs dup 0 67 put cvn def % `C' == 67 + EncodingCommon idx idxname put + NameIndexDict idxname idx put +} for + +/GlobalFontIndex 0 def + +%% fontname dim col fontsize relative-compose baseline-offset fbbx |- -- +/BitmapFont { + 15 dict begin + /FontBBox exch def + /BaselineOffset exch def + /RelativeCompose exch def + /FontSize exch def + /FontBBox [ FontBBox { FontSize div } forall ] def + FontBBox 2 get FontBBox 0 get sub exch div + /FontSpaceWidthRatio exch def + /FontDimension exch def + /FontIndex GlobalFontIndex def + /FontType 3 def + /FontMatrix matrix def + /Encoding EncodingCommon def + /BuildGlyph { BuildGlyphCommon } def + /BuildChar { BuildCharCommon } def + currentdict end + definefont pop + /GlobalFontIndex GlobalFontIndex 1 add def +} bind def + +%% Define a new bitmap font. +%% fontname dim col fontsize relative-compose baseline-offset fbbx |- -- +/NF { + /fbbx exch def + %% Convert BDF's FontBoundingBox to PostScript's FontBBox + [ fbbx 2 get fbbx 3 get + fbbx 2 get fbbx 0 get add fbbx 3 get fbbx 1 get add ] + BitmapFont +} bind def + +%% Define a glyph for the specified font and character. +/NG { % fontname charcode bitmap-data |- -- + /bmp exch def + exch findfont dup /BaselineOffset get bmp 4 get add bmp exch 4 exch put + /FontIndex get exch + dup 256 idiv exch 256 mod GlobalCharName + bmp AddBitmap +} bind def +%%%% End of bitmap font handler + +") + +;; External library support. + +;; The following three functions are to be called from external +;; libraries which support bitmap fonts (e.g. `bdf') to get +;; appropriate PostScript code. + +(defun ps-mule-generate-bitmap-prologue () + (unless ps-mule-bitmap-prologue-generated + (setq ps-mule-bitmap-prologue-generated t) + (list ps-mule-bitmap-prologue))) + +(defun ps-mule-generate-bitmap-font (&rest args) + (list (apply 'format "/%s %d %d %f %S %d %S NF\n" args))) + +(defun ps-mule-generate-bitmap-glyph (font-name code dwidth bbx bitmap) + (format "/%s %d [ %d %d %d %d %d <%s> ] NG\n" + font-name code + dwidth (aref bbx 0) (aref bbx 1) (aref bbx 2) (aref bbx 3) + bitmap)) + +;; Mule specific initializers. + +;;;###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-cmpchar-prologue-generated nil + ps-mule-bitmap-prologue-generated nil) + (mapcar `(lambda (x) (setcar (nthcdr 2 x) nil)) + ps-mule-external-libraries)) + +;;;###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-font-info-database + (cond ((eq ps-multibyte-buffer 'non-latin-printer) + ps-mule-font-info-database-ps) + ((eq ps-multibyte-buffer 'bdf-font) + ps-mule-font-info-database-bdf) + ((eq ps-multibyte-buffer 'bdf-font-except-latin) + ps-mule-font-info-database-ps-bdf) + (t + ps-mule-font-info-database-latin))) + (and (boundp 'enable-multibyte-characters) + enable-multibyte-characters + ;; Initialize `ps-mule-charset-list'. If some characters aren't + ;; printable, warn it. + (let ((charsets (find-charset-region from to))) + (setq charsets (delq 'ascii (delq 'unknown (delq nil charsets)))) + (setq ps-mule-charset-list charsets) + (save-excursion + (goto-char from) + (and (search-forward "\200" to t) + (setq ps-mule-charset-list + (cons 'composition ps-mule-charset-list)))) + (while charsets + (setq charsets + (cond + ((or (eq (car charsets) 'composition) + (ps-mule-printable-p (car charsets))) + (cdr charsets)) + ((y-or-n-p + "Font for some characters not found, continue anyway? ") + nil) + (t + (error "Printing cancelled"))))))) + + (setq ps-mule-current-charset 'ascii) + + (if ps-mule-charset-list + (let ((the-list ps-mule-charset-list) + font-spec elt) + (ps-mule-prologue-generated) + ;; If external functions are necessary, generate prologues for them. + (while the-list + (setq elt (car the-list) + the-list (cdr the-list)) + (cond ((and (eq elt 'composition) + (not ps-mule-cmpchar-prologue-generated)) + (ps-output-prologue ps-mule-cmpchar-prologue) + (setq ps-mule-cmpchar-prologue-generated t)) + ((setq font-spec (ps-mule-get-font-spec elt 'normal)) + (ps-mule-init-external-library font-spec)))))) + + ;; If ASCII font is also specified in ps-mule-font-info-database, + ;; use it istead of what specified in ps-font-info-database. + (let ((font-spec (ps-mule-get-font-spec 'ascii 'normal))) + (if font-spec + (progn + (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 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) + +;;; ps-mule.el ends here -- 2.39.2