Fix bug on selected pages for printing. Use

`color-values' for Emacs 21.  Ensure fontification when jit-lock
is on.  Try to avoid warning messages when compiling.  Doc Fix.
(ps-print-version): New version number (6.3).
(ps-color-device): Use `color-values' to determine if device
supports color.
(ps-color-values): Try to use `x-color-values' when using XEmacs.
(ps-print-page-p): Changed from defsubst to defun.
(ps-page-number): Changed from defmacro to defun.
(ps-header-sheet, ps-header-page): Fix bug on selected pages for
printing.
(ps-print-ensure-fontified): Ensure fontification when jit-lock is
on.
(ps-end-file, ps-dummy-page): Funs eliminated.
(ps-print-color-scale): Changed default value.
(ps-page-n-up, ps-print-page-p): New internal vars.
(ps-print-preprint, ps-output, ps-begin-file, ps-begin-page)
(ps-plot-region, ps-generate, ps-end-job): Code fix.

2 files changed, 237 insertions, 205 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 9edee672e18..32ed0642210 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,24 @@
+2000-10-31  Vinicius Jose Latorre  <vinicius@cpqd.com.br>
+
+        * ps-print.el: Fix bug on selected pages for printing.  Use
+        `color-values' for Emacs 21.  Ensure fontification when jit-lock
+        is on.  Try to avoid warning messages when compiling.  Doc Fix.
+        (ps-print-version): New version number (6.3).
+        (ps-color-device): Use `color-values' to determine if device
+        supports color.
+        (ps-color-values): Try to use `x-color-values' when using XEmacs.
+        (ps-print-page-p): Changed from defsubst to defun.
+        (ps-page-number): Changed from defmacro to defun.
+        (ps-header-sheet, ps-header-page): Fix bug on selected pages for
+        printing.
+        (ps-print-ensure-fontified): Ensure fontification when jit-lock is
+        on.
+        (ps-end-file, ps-dummy-page): Funs eliminated.
+        (ps-print-color-scale): Changed default value.
+        (ps-page-n-up, ps-print-page-p): New internal vars.
+        (ps-print-preprint, ps-output, ps-begin-file, ps-begin-page)
+        (ps-plot-region, ps-generate, ps-end-job): Code fix.
+
 2000-10-31  Kenichi Handa  <handa@etl.go.jp>
 
         * term/mac-win.el: (decode-mac-roman, encode-mac-roman,
diff --git a/lisp/ps-print.el b/lisp/ps-print.el
index 57353f9890c..8d46574755f 100644
--- a/lisp/ps-print.el
+++ b/lisp/ps-print.el
@@ -9,12 +9,12 @@
 ;; Maintainer:  Kenichi Handa <handa@etl.go.jp> (multi-byte characters)
 ;; Maintainer:  Vinicius Jose Latorre <vinicius@cpqd.com.br>
 ;; Keywords:    wp, print, PostScript
-;; Time-stamp:  <2000/10/19 11:54:10 vinicius>
-;; Version:     6.2.1
+;; Time-stamp:  <2000/10/28 23:38:44 Vinicius>
+;; Version:     6.3
 ;; X-URL:       http://www.cpqd.com.br/~vinicius/emacs/
 
-(defconst ps-print-version "6.2.1"
-  "ps-print.el, v 6.2.1 <2000/10/19 vinicius>
+(defconst ps-print-version "6.3"
+  "ps-print.el, v 6.3 <2000/10/28 vinicius>
 
 Vinicius's last change version -- this file may have been edited as part of
 Emacs without changes to the version number.  When reporting bugs, please also
@@ -1301,68 +1301,71 @@ Please send all bug fixes and enhancements to
 
 ;;; Code:
 
-(unless (featurep 'lisp-float-type)
-  (error "`ps-print' requires floating point support"))
-
-
-;; For Emacs 20.2 and the earlier version.
+(eval-and-compile
+  (unless (featurep 'lisp-float-type)
+    (error "`ps-print' requires floating point support"))
 
-(or (fboundp 'set-buffer-multibyte)
-    (defun set-buffer-multibyte (arg)
-      (setq enable-multibyte-characters arg)))
 
-(or (fboundp 'string-as-unibyte)
-    (defun string-as-unibyte (arg) arg))
+  ;; For Emacs 20.2 and the earlier version.
 
-(or (fboundp 'string-as-multibyte)
-    (defun string-as-multibyte (arg) arg))
+  (or (fboundp 'set-buffer-multibyte)
+      (defun set-buffer-multibyte (arg)
+        (setq enable-multibyte-characters arg)))
 
-(or (fboundp 'char-charset)
-    (defun char-charset (arg) 'ascii))
+  (or (fboundp 'string-as-unibyte)
+      (defun string-as-unibyte (arg) arg))
 
-(or (fboundp 'charset-after)
-    (defun charset-after (&optional arg)
-      (char-charset (char-after arg))))
+  (or (fboundp 'string-as-multibyte)
+      (defun string-as-multibyte (arg) arg))
 
+  (or (fboundp 'char-charset)
+      (defun char-charset (arg) 'ascii))
 
-;; GNU Emacs
-(or (fboundp 'line-beginning-position)
-    (defun line-beginning-position (&optional n)
-      (save-excursion
-        (and n (/= n 1) (forward-line (1- n)))
-        (beginning-of-line)
-        (point))))
+  (or (fboundp 'charset-after)
+      (defun charset-after (&optional arg)
+        (char-charset (char-after arg))))
 
 
-;; to avoid compilation gripes
-
-;; XEmacs
-(defalias 'ps-x-color-instance-p              'color-instance-p)
-(defalias 'ps-x-color-instance-rgb-components 'color-instance-rgb-components)
-(defalias 'ps-x-color-name                    'color-name)
-(defalias 'ps-x-color-specifier-p             'color-specifier-p)
-(defalias 'ps-x-copy-coding-system            'copy-coding-system)
-(defalias 'ps-x-device-class                  'device-class)
-(defalias 'ps-x-extent-end-position           'extent-end-position)
-(defalias 'ps-x-extent-face                   'extent-face)
-(defalias 'ps-x-extent-priority               'extent-priority)
-(defalias 'ps-x-extent-start-position         'extent-start-position)
-(defalias 'ps-x-face-font-instance            'face-font-instance)
-(defalias 'ps-x-find-coding-system            'find-coding-system)
-(defalias 'ps-x-font-instance-properties      'font-instance-properties)
-(defalias 'ps-x-make-color-instance           'make-color-instance)
-(defalias 'ps-x-map-extents                   'map-extents)
-
-;; GNU Emacs
-(if (fboundp 'find-composition)
-    (defalias 'ps-e-find-composition 'find-composition)
-  (defalias 'ps-e-find-composition 'ignore))
-
-
-(defconst ps-windows-system
-  (memq system-type '(emx win32 w32 mswindows ms-dos windows-nt)))
-(defconst ps-lp-system
-  (memq system-type '(usq-unix-v dgux hpux irix)))
+  ;; GNU Emacs
+  (or (fboundp 'line-beginning-position)
+      (defun line-beginning-position (&optional n)
+        (save-excursion
+          (and n (/= n 1) (forward-line (1- n)))
+          (beginning-of-line)
+          (point))))
+
+
+  ;; to avoid compilation gripes
+
+  ;; XEmacs
+  (defalias 'ps-x-color-instance-p              'color-instance-p)
+  (defalias 'ps-x-color-instance-rgb-components 'color-instance-rgb-components)
+  (defalias 'ps-x-color-name                    'color-name)
+  (defalias 'ps-x-color-specifier-p             'color-specifier-p)
+  (defalias 'ps-x-copy-coding-system            'copy-coding-system)
+  (defalias 'ps-x-device-class                  'device-class)
+  (defalias 'ps-x-extent-end-position           'extent-end-position)
+  (defalias 'ps-x-extent-face                   'extent-face)
+  (defalias 'ps-x-extent-priority               'extent-priority)
+  (defalias 'ps-x-extent-start-position         'extent-start-position)
+  (defalias 'ps-x-face-font-instance            'face-font-instance)
+  (defalias 'ps-x-find-coding-system            'find-coding-system)
+  (defalias 'ps-x-font-instance-properties      'font-instance-properties)
+  (defalias 'ps-x-make-color-instance           'make-color-instance)
+  (defalias 'ps-x-map-extents                   'map-extents)
+
+  ;; GNU Emacs
+  (defalias 'ps-e-x-color-values 'x-color-values)
+  (defalias 'ps-e-color-values   'color-values)
+  (if (fboundp 'find-composition)
+      (defalias 'ps-e-find-composition 'find-composition)
+    (defalias 'ps-e-find-composition 'ignore))
+
+
+  (defconst ps-windows-system
+    (memq system-type '(emx win32 w32 mswindows ms-dos windows-nt)))
+  (defconst ps-lp-system
+    (memq system-type '(usq-unix-v dgux hpux irix))))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1722,7 +1725,9 @@ After ps-print processing `ps-selected-pages' is set to nil.  But the latest
 `ps-selected-pages' is saved in `ps-last-selected-pages' (see it for
 documentation).  So you can restore the latest selected pages by using
 `ps-last-selected-pages' or by calling `ps-restore-selected-pages' command (see
-it for documentation)."
+it for documentation).
+
+See also `ps-even-or-odd-pages'."
   :type '(repeat :tag "Selected Pages"
                  (radio :tag "Page"
                         (integer :tag "Number")
@@ -1742,7 +1747,20 @@ Valid values are:
 
    `odd'        print only odd pages.
 
-Any other value is treated as nil."
+Any other value is treated as nil.
+
+If you set `ps-selected-pages' (see it for documentation), first the pages are
+filtered by `ps-selected-pages' and then by `ps-even-or-odd-pages'.  For
+example, if we have:
+
+   (setq ps-selected-pages '(1 4 (6 . 10) 12))
+
+We have the following results:
+
+   `ps-even-or-odd-pages'       PAGES PRINTED
+        nil                     1, 4, 6, 7, 8, 9, 10, 12
+        even                    4, 6, 8, 10, 12
+        odd                     1, 7, 9"
   :type '(choice :menu-tag "Print Even/Odd Pages"
                  :tag "Print Even/Odd Pages"
                  (const :tag "All Pages" nil)
@@ -2415,8 +2433,11 @@ it uses the fonts resident in your printer."
 ;;; Colors
 
 ;; Printing color requires x-color-values.
-(defcustom ps-print-color-p (or (fboundp 'x-color-values) ; Emacs
-                                (fboundp 'color-instance-rgb-components))
+(defcustom ps-print-color-p
+  (or (and (fboundp 'color-values)      ; Emacs
+           (ps-e-color-values "Green"))
+      (fboundp 'x-color-values)         ; Emacs
+      (fboundp 'color-instance-rgb-components))
                                         ; XEmacs
   "*Non-nil means print the buffer's text in color."
   :type 'boolean
@@ -2911,17 +2932,18 @@ The table depends on the current ps-print setup."
 
   ;; Return t if the device (which can be changed during an emacs session)
   ;; can handle colors.
-  ;; This is function is not yet implemented for GNU emacs.
+  ;; This function is not yet implemented for GNU emacs.
   (cond ((and (eq ps-print-emacs-type 'xemacs)
               (>= emacs-minor-version 12)) ; xemacs
          (defun ps-color-device ()
-           (eq (ps-x-device-class) 'color))
-         )
+           (eq (ps-x-device-class) 'color)))
 
         (t                              ; emacs
          (defun ps-color-device ()
-           t)
-         ))
+           (if (fboundp 'color-values)
+               (ps-e-color-values "Green")
+             t))))
+
 
   (defun ps-mapper (extent list)
     (nconc list
@@ -2951,9 +2973,13 @@ The table depends on the current ps-print setup."
   (cond ((eq ps-print-emacs-type 'emacs) ; emacs
 
          (defun ps-color-values (x-color)
-           (if (fboundp 'x-color-values)
-               (x-color-values x-color)
-             (error "No available function to determine X color values.")))
+           (cond
+            ((fboundp 'color-values)
+             (ps-e-color-values x-color))
+            ((fboundp 'x-color-values)
+             (ps-e-x-color-values x-color))
+            (t
+             (error "No available function to determine X color values."))))
 
          (defalias 'ps-face-foreground-name 'face-foreground)
          (defalias 'ps-face-background-name 'face-background)
@@ -2977,7 +3003,7 @@ The table depends on the current ps-print setup."
            (let ((color (ps-xemacs-color-name x-color)))
              (cond
               ((fboundp 'x-color-values)
-               (x-color-values color))
+               (ps-e-x-color-values color))
               ((and (fboundp 'color-instance-rgb-components)
                     (ps-color-device))
                (ps-x-color-instance-rgb-components
@@ -3004,7 +3030,7 @@ The table depends on the current ps-print setup."
          )))
 
 
-(defvar ps-print-color-scale nil)
+(defvar ps-print-color-scale 1.0)
 
 (defun ps-color-scale (color)
   ;; Scale 16-bit X-COLOR-VALUE to PostScript color value in [0, 1] interval.
@@ -3057,9 +3083,11 @@ The table depends on the current ps-print setup."
 (defvar ps-page-postscript 0)
 (defvar ps-page-order 0)
 (defvar ps-page-count 0)
+(defvar ps-page-n-up 0)
 (defvar ps-showline-count 1)
 (defvar ps-first-page nil)
 (defvar ps-last-page nil)
+(defvar ps-print-page-p t)
 
 (defvar ps-control-or-escape-regexp nil)
 (defvar ps-n-up-on nil)
@@ -3614,16 +3642,19 @@ page-height == bm + print-height + tm - ho - hh
                               ".ps"))
               (prompt (format "Save PostScript to file: (default %s) " name))
               (res    (read-file-name prompt default-directory name nil)))
-         (while (cond ((not (file-writable-p res))
+         (while (cond ((file-directory-p res)
+                       (ding)
+                       (setq prompt "It's a directory"))
+                      ((not (file-writable-p res))
                        (ding)
-                       (setq prompt "is unwritable"))
+                       (setq prompt "File is unwritable"))
                       ((file-exists-p res)
-                       (setq prompt "exists")
+                       (setq prompt "File exists")
                        (not (y-or-n-p (format "File `%s' exists; overwrite? "
                                               res))))
                       (t nil))
            (setq res (read-file-name
-                      (format "File %s; save PostScript to file: " prompt)
+                      (format "%s; save PostScript to file: " prompt)
                       (file-name-directory res) nil nil
                       (file-name-nondirectory res))))
          (if (file-directory-p res)
@@ -3691,26 +3722,27 @@ page-height == bm + print-height + tm - ho - hh
                 (< ps-last-page ps-page-postscript)))))
 
 
-(defsubst ps-print-page-p ()
-  (and (cond ((null ps-first-page))
-             ((<= ps-page-postscript ps-last-page)
-              (<= ps-first-page ps-page-postscript))
-             (ps-selected-pages
-              (ps-selected-pages)
-              (and (<= ps-first-page ps-page-postscript)
-                   (<= ps-page-postscript ps-last-page)))
-             (t
-              nil))
-       (cond ((eq ps-even-or-odd-pages 'even)
-              (= (logand ps-page-postscript 1) 0))
-             ((eq ps-even-or-odd-pages 'odd)
-              (= (logand ps-page-postscript 1) 1))
-             (t)
-             )))
+(defun ps-print-page-p ()
+  (setq ps-print-page-p
+        (and (cond ((null ps-first-page))
+                   ((<= ps-page-postscript ps-last-page)
+                    (<= ps-first-page ps-page-postscript))
+                   (ps-selected-pages
+                    (ps-selected-pages)
+                    (and (<= ps-first-page ps-page-postscript)
+                         (<= ps-page-postscript ps-last-page)))
+                   (t
+                    nil))
+             (cond ((eq ps-even-or-odd-pages 'even)
+                    (= (logand ps-page-postscript 1) 0))
+                   ((eq ps-even-or-odd-pages 'odd)
+                    (= (logand ps-page-postscript 1) 1))
+                   (t)
+                   ))))
 
 
 (defun ps-output (&rest args)
-  (when (ps-print-page-p)
+  (when ps-print-page-p
     (setcdr ps-output-tail args)
     (while (cdr ps-output-tail)
       (setq ps-output-tail (cdr ps-output-tail)))))
@@ -4388,6 +4420,8 @@ XSTART YSTART are the relative position for the first page in a sheet.")
   (ps-get-page-dimensions)
   (setq ps-page-postscript 0
         ps-page-order 0
+        ps-page-n-up 0
+        ps-print-page-p t
         ps-background-text-count 0
         ps-background-image-count 0
         ps-background-pages nil
@@ -4733,36 +4767,10 @@ XSTART YSTART are the relative position for the first page in a sheet.")
         ))
 
 
-(defmacro ps-page-number ()
-  `(1+ (/ (1- ps-page-count) ps-number-of-columns)))
-
-(defun ps-end-file (needs-begin-file)
-  (let (ps-even-or-odd-pages)
-    (ps-flush-output)
-    ;; Back to the PS output buffer to set the last page n-up printing
-    (save-excursion
-      (let ((pages-per-sheet (mod ps-page-postscript ps-n-up-printing))
-            case-fold-search)
-        (set-buffer ps-spool-buffer)
-        (goto-char (point-max))
-        (and (> pages-per-sheet 0)
-             (re-search-backward "^[0-9]+ BeginSheet$" nil t)
-             (replace-match (format "%d BeginSheet" pages-per-sheet) t))))
-    ;; Set dummy page
-    (and ps-spool-duplex (= (mod ps-page-order 2) 1)
-         (let (ps-first-page)
-           (ps-dummy-page)))
-    ;; Set end of PostScript file
-    (or ps-first-page
-        (ps-output "EndSheet\n"))
-    (setq ps-first-page nil)            ; disable selected pages
-    (ps-output "\n%%Trailer\n%%Pages: "
-               (format "%d"
-                       (if (and needs-begin-file
-                                ps-banner-page-when-duplexing)
-                           (1+ ps-page-order)
-                         ps-page-order))
-               "\n\nEndDoc\n\n%%EOF\n")))
+(defun ps-page-number ()
+  (if ps-print-only-one-header
+      (1+ (/ (1- ps-page-count) ps-number-of-columns))
+    ps-page-count))
 
 
 (defun ps-next-page ()
@@ -4773,45 +4781,39 @@ XSTART YSTART are the relative position for the first page in a sheet.")
 
 (defun ps-header-sheet ()
   ;; Print only when a new sheet begins.
-  (let ((print-posterior (ps-print-page-p)))
-    (setq ps-page-postscript (1+ ps-page-postscript))
-    (cond ((ps-print-page-p)
-           (setq ps-page-order (1+ ps-page-order))
-           (and (or print-posterior ps-even-or-odd-pages) (> ps-page-order 1)
-                (ps-output "EndSheet\n"))
-           (ps-output (if ps-n-up-on
-                          (format "\n%%%%Page: (%d \\(%d\\)) %d\n"
-                                  ps-page-order ps-page-postscript ps-page-order)
-                        (format "\n%%%%Page: %d %d\n"
-                                ps-page-postscript ps-page-order))
-                      (format "%d BeginSheet\nBeginDSCPage\n"
-                              ps-n-up-printing)))
-          (print-posterior
-           (let (ps-first-page)
-             (ps-output "EndSheet\n"))))))
-
-
-(defsubst ps-header-page ()
+  (setq ps-page-order (1+ ps-page-order))
+  (and (> ps-page-order 1)
+       (ps-output "EndSheet\n"))
+  (ps-output (if ps-n-up-on
+                 (format "\n%%%%Page: (%d \\(%d\\)) %d\n"
+                         ps-page-order ps-page-postscript ps-page-order)
+               (format "\n%%%%Page: %d %d\n"
+                       ps-page-postscript ps-page-order))
+             (format "%d BeginSheet\nBeginDSCPage\n"
+                     ps-n-up-printing)))
+
+
+(defun ps-header-page ()
   ;; set total line and page number when printing has finished
   ;; (see `ps-generate')
-  (run-hooks
-   (if (prog1
-           (zerop (mod ps-page-count ps-number-of-columns))
-         (setq ps-page-count (1+ ps-page-count)))
-       (prog1
-           (if (zerop (mod ps-page-postscript ps-n-up-printing))
-               ;; Print only when a new sheet begins.
-               (progn
-                 (ps-header-sheet)
-                 'ps-print-begin-sheet-hook)
-             ;; Print only when a new page begins.
-             (setq ps-page-postscript (1+ ps-page-postscript))
-             (ps-output "BeginDSCPage\n")
-             'ps-print-begin-page-hook)
-         (ps-background ps-page-postscript))
-     ;; Print only when a new column begins.
-     (ps-output "BeginDSCPage\n")
-     'ps-print-begin-column-hook)))
+  (if (zerop (mod ps-page-count ps-number-of-columns))
+      (progn
+        (setq ps-page-postscript (1+ ps-page-postscript))
+        (when (ps-print-page-p)
+          (if (zerop (mod ps-page-n-up ps-n-up-printing))
+              ;; Print only when a new sheet begins.
+              (progn
+                (ps-header-sheet)
+                (run-hooks 'ps-print-begin-sheet-hook))
+            ;; Print only when a new page begins.
+            (ps-output "BeginDSCPage\n")
+            (run-hooks 'ps-print-begin-page-hook))
+          (ps-background ps-page-postscript)
+          (setq ps-page-n-up (1+ ps-page-n-up))))
+    ;; Print only when a new column begins.
+    (ps-output "BeginDSCPage\n")
+    (run-hooks 'ps-print-begin-column-hook))
+  (setq ps-page-count (1+ ps-page-count)))
 
 (defun ps-begin-page ()
   (ps-get-page-dimensions)
@@ -4821,9 +4823,7 @@ XSTART YSTART are the relative position for the first page in a sheet.")
   (ps-header-page)
 
   (ps-output (format "/LineNumber %d def\n" ps-showline-count)
-             (format "/PageNumber %d def\n" (if ps-print-only-one-header
-                                                (ps-page-number)
-                                              ps-page-count)))
+             (format "/PageNumber %d def\n" (ps-page-number)))
 
   (when ps-print-header
     (ps-generate-header "HeaderLinesLeft"    ps-left-header)
@@ -4839,17 +4839,6 @@ XSTART YSTART are the relative position for the first page in a sheet.")
 (defun ps-end-page ()
   (ps-output "EndPage\nEndDSCPage\n"))
 
-(defun ps-dummy-page ()
-  (let ((ps-n-up-printing 0))
-    (ps-header-sheet))
-  (ps-output "/PrintHeader false def
-/ColumnIndex 0 def
-/PrintLineNumber false def
-BeginPage
-EndPage
-EndDSCPage\n")
-  (setq ps-page-postscript ps-n-up-printing))
-
 (defun ps-next-line ()
   (setq ps-showline-count (1+ ps-showline-count))
   (let ((lh (ps-line-height 'ps-font-for-text)))
@@ -4969,7 +4958,7 @@ EndDSCPage\n")
       (if (re-search-forward ps-control-or-escape-regexp to t)
           ;; region with some control characters or some multi-byte characters
           (let* ((match-point (match-beginning 0))
-                 (match (char-after match-point))
+                 (match       (char-after match-point))
                  (composition (ps-e-find-composition from (1+ match-point))))
             (if composition
                 (if (and (nth 2 composition)
@@ -5215,12 +5204,14 @@ If FACE is not a valid face name, it is used default face."
 
 
 ;; to avoid compilation gripes
-(eval-and-compile
-  (require 'lazy-lock)
-
-  (defun ps-print-ensure-fontified (start end)
-    (and (boundp 'lazy-lock-mode) (symbol-value 'lazy-lock-mode)
-         (lazy-lock-fontify-region start end))))
+(defun ps-print-ensure-fontified (start end)
+  (cond
+   ((and (boundp 'jit-lock-mode) (symbol-value 'jit-lock-mode))
+    (defalias 'ps-jitify 'jit-lock-fontify-now) ; avoid compilation gripes
+    (ps-jitify start end))
+   ((and (boundp 'lazy-lock-mode) (symbol-value 'lazy-lock-mode))
+    (defalias 'ps-lazify 'lazy-lock-fontify-region) ; avoid compilation gripes
+    (ps-lazify start end))))
 
 
 (defun ps-generate-postscript-with-faces (from to)
@@ -5263,9 +5254,8 @@ If FACE is not a valid face name, it is used default face."
             ;; XEmacs 19.12: for some reason, we're getting into a
             ;; situation in which some of the records have
             ;; positions less than 'from'.  Since we've narrowed
-            ;; the buffer, this'll generate errors.  This is a
-            ;; hack, but don't call ps-plot-with-face unless from >
-            ;; point-min.
+            ;; the buffer, this'll generate errors.  This is a hack,
+            ;; but don't call ps-plot-with-face unless from > point-min.
             (and (>= from (point-min))
                  (ps-plot-with-face from (min position (point-max)) face))
 
@@ -5372,22 +5362,21 @@ If FACE is not a valid face name, it is used default face."
                 (goto-char (point-min))
                 (or (looking-at (regexp-quote ps-adobe-tag))
                     (setq needs-begin-file t))
+
+                (set-buffer ps-source-buffer)
                 (save-excursion
-                  (set-buffer ps-source-buffer)
-                  (let (ps-even-or-odd-pages)
+                  (let ((ps-print-page-p t)
+                        ps-even-or-odd-pages)
                     (ps-begin-job)
                     (when needs-begin-file
                       (ps-begin-file)
                       (ps-mule-initialize))
                     (ps-mule-begin-job from to)
-                    (ps-selected-pages))
-                  (ps-begin-page))
-                (set-buffer ps-source-buffer)
+                    (ps-selected-pages)))
+                (ps-begin-page)
                 (funcall genfunc from to)
                 (ps-end-page)
-
-                (ps-end-file needs-begin-file)
-                (ps-end-job)
+                (ps-end-job needs-begin-file)
 
                 ;; Setting this variable tells the unwind form that the
                 ;; the PostScript was generated without error.
@@ -5405,20 +5394,42 @@ If FACE is not a valid face name, it is used default face."
         (and ps-razzle-dazzle (message "Formatting...done"))))))
 
 
-(defun ps-end-job ()
-  (ps-flush-output)
-  (let ((total-lines (cdr ps-printing-region))
-        (total-pages (if ps-print-only-one-header
-                         (ps-page-number)
-                       ps-page-count))
-        case-fold-search)
-    (set-buffer ps-spool-buffer)
-    ;; Back to the PS output buffer to set the page count
-    (goto-char (point-min))
-    (and (re-search-forward "^/Lines 0 def\n/PageCount 0 def$" nil t)
-         (replace-match (format "/Lines %d def\n/PageCount %d def"
-                                total-lines total-pages) t)))
-  ;; selected pages
+(defun ps-end-job (needs-begin-file)
+  (let ((ps-print-page-p t))
+    (ps-flush-output)
+    (save-excursion
+      (let ((pages-per-sheet (mod ps-page-n-up ps-n-up-printing))
+            (total-lines (cdr ps-printing-region))
+            (total-pages (ps-page-number))
+            case-fold-search)
+        (set-buffer ps-spool-buffer)
+        ;; Back to the PS output buffer to set the last page n-up printing
+        (goto-char (point-max))
+        (and (> pages-per-sheet 0)
+             (re-search-backward "^[0-9]+ BeginSheet$" nil t)
+             (replace-match (format "%d BeginSheet" pages-per-sheet) t))
+        ;; Back to the PS output buffer to set the page count
+        (goto-char (point-min))
+        (and (re-search-forward "^/Lines 0 def\n/PageCount 0 def$" nil t)
+             (replace-match (format "/Lines %d def\n/PageCount %d def"
+                                    total-lines total-pages) t))))
+    ;; Set dummy page
+    (and ps-spool-duplex (= (mod ps-page-order 2) 1)
+         (let ((ps-n-up-printing 0))
+           (ps-header-sheet)
+           (ps-output "/PrintHeader false def\n/ColumnIndex 0 def\n"
+                      "/PrintLineNumber false def\nBeginPage\n")
+           (ps-end-page)))
+    ;; Set end of PostScript file
+    (ps-output "EndSheet\n\n%%Trailer\n%%Pages: "
+               (number-to-string
+                (if (and needs-begin-file
+                         ps-banner-page-when-duplexing)
+                    (1+ ps-page-order)
+                  ps-page-order))
+               "\n\nEndDoc\n\n%%EOF\n")
+    (ps-flush-output))
+  ;; disable selected pages
   (setq ps-selected-pages nil))