XEmacs compatibility. Doc fix.

(leading-code-private-22): Declare var if it's not declared yet.
(charset-bytes, charset-dimension, charset-id, charset-width)
(find-charset-region, split-char, char-width, chars-in-region)
(forward-point, decompose-composite-char, encode-coding-string)
(coding-system-p, ccl-execute-on-string, define-ccl-program):
Define funs if not defined yet.
(encode-composition-rule, find-composition): Define funs if not
loaded yet.
(ps-mule-prologue): PostScript code fix.

(ps-mule-generate-font): New arg HEADER-P.  If it is
non-nil, generate font for the header strings.
(ps-mule-prepare-font): Likewise.
(ps-mule-generate-glyphs): Likewise.
(ps-mule-string-encoding): Likewise.
(ps-mule-header-charsets): New variable.
(ps-mule-encode-header-string): New function.
(ps-mule-header-string-charsets): New function.
(ps-mule-begin-job): Check charsets in the header strings.  If there
are non-ASCII and non-Latin1 charsets, prepare fonts for them.

1 files changed, 242 insertions, 62 deletions

diff --git a/lisp/ps-mule.el b/lisp/ps-mule.el
index 7cf3c781242..efc9820253c 100644
--- a/lisp/ps-mule.el
+++ b/lisp/ps-mule.el
@@ -1,13 +1,13 @@
 ;;; ps-mule.el --- Provide multi-byte character facility to ps-print.
 
-;; Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+;; Copyright (C) 1998,99,00,2001 Free Software Foundation, Inc.
 
 ;; Author:      Vinicius Jose Latorre <vinicius@cpqd.com.br>
 ;; Author:      Kenichi Handa <handa@etl.go.jp> (multi-byte characters)
 ;; Maintainer:  Kenichi Handa <handa@etl.go.jp> (multi-byte characters)
 ;; Maintainer:  Vinicius Jose Latorre <vinicius@cpqd.com.br>
 ;; Keywords:    wp, print, PostScript, multibyte, mule
-;; Time-stamp:  <2000/08/01 11:17:35 vinicius>
+;; Time-stamp:  <2001/03/16 18:50:59 Handa>
 
 ;; This file is part of GNU Emacs.
 
@@ -68,10 +68,10 @@
 ;;                          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
+;;                          `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.1' and set the variable
+;;                          `intlfonts-1.2' and set the variable
 ;;                          `bdf-directory-list' appropriately (see ps-bdf.el
 ;;                          for documentation of this variable).
 ;;
@@ -90,7 +90,63 @@
 
 ;;; Code:
 
-(eval-and-compile (require 'ps-print))
+(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 '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))))
 
 
 ;;;###autoload
@@ -121,10 +177,10 @@ Valid values are:
                           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
+                          `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.1' and set the variable
+                          `intlfonts-1.2' and set the variable
                           `bdf-directory-list' appropriately (see ps-bdf.el for
                           documentation of this variable).
 
@@ -141,15 +197,17 @@ Any other value is treated as nil."
   :group 'ps-print-font)
 
 
-;; For Emacs 20.2 and the earlier version.
 (eval-and-compile
-  (if (and (boundp 'mule-version)       ; only if mule package is loaded
-           (not (string< mule-version "4.0")))
+  ;; For Emacs 20.2 and the earlier version.
+  (if (and (boundp 'mule-version)
+           (not (string< (symbol-value 'mule-version) "4.0")))
+      ;; mule package is loaded
       (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)))
+    ;; mule package isn't loaded or mule version lesser than 4.0
     (defun ps-mule-next-point (arg)
       (save-excursion (goto-char arg) (forward-char 1) (point)))
     (defun ps-mule-chars-in-string (string)
@@ -159,24 +217,32 @@ Any other value is treated as nil."
       (string-to-char (substring string idx)))
     (defun ps-mule-next-index (string i)
       (+ i (charset-bytes (char-charset (string-to-char string)))))
+    )
+  ;; For Emacs 20.4 and the earlier version.
+  (if (and (boundp 'mule-version)
+           (string< (symbol-value 'mule-version) "5.0"))
+      ;; mule package is loaded and mule version is lesser than 5.0
+      (progn
+        (defun encode-composition-rule (rule)
+          (if (= (car rule) 4) (setcar rule 10))
+          (if (= (cdr rule) 4) (setcdr rule 10))
+          (+ (* (car rule) 12) (cdr rule)))
+        (defun find-composition (pos &rest ignore)
+          (let ((ch (char-after pos)))
+            (if (eq (char-charset ch) 'composition)
+                (let ((components (decompose-composite-char ch 'vector t)))
+                  (list pos (ps-mule-next-point pos) components
+                        (integerp (aref components 1)) nil
+                        (char-width ch)))))))
+    ;; mule package isn't loaded
+    (or (fboundp 'encode-composition-rule)
+        (defun encode-composition-rule (rule)
+          130))
+    (or (fboundp 'find-composition)
+        (defun find-composition (pos &rest ignore)
+          nil))
     ))
 
-;; For Emacs 20.4 and the earlier version.
-(eval-and-compile
- (when (and (boundp 'mule-version)
-            (string< mule-version "5.0"))
-   (defun encode-composition-rule (rule)
-     (if (= (car rule) 4) (setcar rule 10))
-     (if (= (cdr rule) 4) (setcdr rule 10))
-     (+ (* (car rule) 12) (cdr rule)))
-   (defun find-composition (pos &rest ignore)
-     (let ((ch (char-after pos)))
-       (if (eq (char-charset ch) 'composition)
-           (let ((components (decompose-composite-char ch 'vector t)))
-             (list pos (ps-mule-next-point pos) components
-                   (integerp (aref components 1)) nil
-                   (char-width ch))))))))
-
 (defvar ps-mule-font-info-database
   nil
   "Alist of charsets with the corresponding font information.
@@ -192,7 +258,7 @@ 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 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'
@@ -343,7 +409,7 @@ Currently, data for Japanese and Korean PostScript printers are listed.")
 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
+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
@@ -356,7 +422,7 @@ See also `ps-mule-font-info-database-ps-bdf'.")
         (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
+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
@@ -506,30 +572,42 @@ See the documentation of `ps-mule-get-font-spec' for FONT-SPEC's meaning."
 ;;       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."
+(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
-          (if (eq charset 'ascii)
-              (format "f%d" ps-current-font)
-            (format "f%02x-%d"
-                    (charset-id charset) ps-current-font))))
+          (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 ps-font-size-internal font-name
-                   (if (eq ps-mule-current-charset 'ascii) "Ascii" ""))))
+                   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 ps-current-font scaled-font-name)
+                (cons (cons current-font scaled-font-name)
                       (nth 1 font-cache)))
       (setq font-cache (list font-name
-                             (list (cons ps-current-font scaled-font-name))
+                             (list (cons current-font scaled-font-name))
                              'cache)
             ps-mule-font-cache (cons font-cache ps-mule-font-cache)))
     font-cache))
@@ -543,21 +621,26 @@ See the documentation of `ps-mule-get-font-spec' for FONT-SPEC's meaning."
           (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)
+(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 arg NO-SETFONT is non-nil, don't generate the code for setting the
-current font."
+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 ps-current-font (nth 1 font-cache)))
-        (setq font-cache (ps-mule-generate-font font-spec charset)))
+    (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 ps-current-font (nth 1 font-cache)))))
+        (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))
@@ -616,7 +699,7 @@ STRING should contain only ASCII characters."
   dup length 2 add dict begin
     { 1 index /FID ne { def } { pop pop } ifelse } forall
     currentdict /BaselineOffset known {
-        BaselineOffset false eq { /BaselinfOffset 0 def } if
+        BaselineOffset false eq { /BaselineOffset 0 def } if
     } {
       /BaselineOffset 0 def
     } ifelse
@@ -698,7 +781,7 @@ The search starts at FROM and goes until TO.
 Optional 4th arg COMPOSITION, if non-nil, is information of
 composition starting at FROM.
 
-If COMPOSTION is nil, it is assumed that all characters between 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.
@@ -736,7 +819,7 @@ the sequence."
 
 ;;;###autoload
 (defun ps-mule-plot-string (from to &optional bg-color)
-  "Generate PostScript code for ploting characters in the region FROM and TO.
+  "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.
 
@@ -787,7 +870,7 @@ the sequence."
 
 ;;;###autoload
 (defun ps-mule-plot-composition (from to &optional bg-color)
-  "Generate PostScript code for ploting composition in the region FROM and TO.
+  "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.
@@ -876,7 +959,7 @@ the sequence."
 (defvar ps-mule-composition-prologue-generated nil)
 
 (defconst ps-mule-composition-prologue
-  "%%%% Character compositition handler
+  "%%%% Character composition handler
 /RelativeCompositionSkip 0.4 def
 
 %% Get a bounding box (relative to currentpoint) of STR.
@@ -919,8 +1002,8 @@ the sequence."
     Effect 32 and 0 ne { true doOutline } { show } ifelse
 } def
 
-%% Draw COMPONETS which have the form [ font0? [str0 xoff0 yoff0] ... ].
-/ShowComponents {                                       % compoents  |-  -
+%% 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
@@ -1003,7 +1086,7 @@ the sequence."
             elt dup FM
         } { elt type /integertype eq {                  % rule
             %% This RULE decoding should be compatible with macro
-            %% COMPOSITION_DECODE_RULE in emcas/src/composite.h.
+            %% 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
@@ -1046,16 +1129,17 @@ the sequence."
 %%%% End of character composition handler
 
 "
-  "PostScript code for printing character compositition.")
+  "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, Postscript codes for the font and glyphs to print
-;; STRING are generated.
-(defun ps-mule-string-encoding (font-spec str &optional no-setfont)
+;; If necessary, it's generated 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
@@ -1068,7 +1152,9 @@ the sequence."
                  (t
                   str))))
     (if (ps-mule-font-spec-src font-spec)
-        (ps-mule-prepare-font font-spec str ps-mule-current-charset no-setfont)
+        (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))
@@ -1166,7 +1252,7 @@ NewBitmapDict
     1 index /BuildGlyph get exec
 } bind def
 
-%% Bitmap font creater
+%% Bitmap font creator
 
 %% Common Encoding shared by all bitmap fonts.
 /EncodingCommon 256 array def
@@ -1257,11 +1343,84 @@ NewBitmapDict
   (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 (if (multibyte-string-p string)
+                   (copy-sequence string)
+                 (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)))
+          (dotimes (i len)
+            (or (memq (char-charset (aref string i)) '(ascii latin-iso8859-1))
+                (aset string 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)))
+              (dotimes (i len)
+                (or (memq (char-charset (aref string i))
+                          '(ascii latin-iso8859-1))
+                    (aset string i ??)))
+              (setq string (encode-coding-string string 'iso-latin-1)))
+          (let ((charsets (list 'ascii (car ps-mule-header-charsets)))
+                (len (length string)))
+            (dotimes (i len)
+              (or (memq (char-charset (aref string i)) charsets)
+                  (aset string i ??))))
+          (setq string (ps-mule-string-encoding font-spec string nil t))))))
+  string)
+
+;;;###autoload
+(defun ps-mule-header-string-charsets ()
+  "Return a list of character sets that appears in header strings."
+  (let ((str "")
+        len charset charset-list)
+    (when ps-print-header
+      (dolist (tail (list ps-left-header ps-right-header))
+        ;; Simulate what is done by ps-generate-header-line to get a
+        ;; string to plot.
+        (let ((count 0))
+          (dolist (elt tail)
+            (if (< count ps-header-lines)
+                (setq str (concat str (cond ((stringp elt) elt)
+                                            ((and (symbolp elt) (fboundp elt))
+                                             (funcall elt))
+                                            ((and (symbolp elt) (boundp elt))
+                                             (symbol-value elt))
+                                            (t "")))
+                      count (1+ count)))))))
+    (setq len (length str))
+    (dotimes (i len)
+      (setq charset (char-charset (aref str i)))
+      (or (eq charset 'ascii)
+          (memq charset charset-list)
+          (setq charset-list (cons charset charset-list))))
+    charset-list))
+
 ;;;###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)
@@ -1283,6 +1442,15 @@ This checks if all multi-byte characters in the region are printable or not."
            (and (search-forward "\200" to t)
                 (setq ps-mule-charset-list
                       (cons 'composition ps-mule-charset-list))))
+         ;; We also have to check non-ASCII charsets in the header strings.
+         (let ((tail (ps-mule-header-string-charsets)))
+           (while tail
+             (unless (eq (car tail) 'ascii)
+               (setq ps-mule-header-charsets
+                     (cons (car tail) ps-mule-header-charsets))
+               (or (memq (car tail) charsets)
+                   (setq charsets (cons (car tail) charsets))))
+             (setq tail (cdr tail))))
          (while charsets
            (setq charsets
                  (cond
@@ -1304,8 +1472,8 @@ This checks if all multi-byte characters in the region are printable or not."
         (ps-output-prologue ps-mule-composition-prologue)
         (setq ps-mule-composition-prologue-generated t)))
 
-  (if ps-mule-charset-list
-      (let ((the-list ps-mule-charset-list)
+  (if (or ps-mule-charset-list ps-mule-header-charsets)
+      (let ((the-list (append ps-mule-header-charsets ps-mule-charset-list))
             font-spec elt)
         (ps-mule-prologue-generated)
         ;; If external functions are necessary, generate prologues for them.
@@ -1320,7 +1488,7 @@ This checks if all multi-byte characters in the region are printable or not."
                  (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.
+  ;; 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
@@ -1335,6 +1503,18 @@ This checks if all multi-byte characters in the region are printable or not."
               (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 occurance of such characters.
+  (if (and ps-mule-header-charsets
+           (not (eq (car ps-mule-header-charsets) 'latin-iso8859-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