[Emacs-diffs] Changes to emacs/lisp/international/mule-cmds.el [emacs-unicode-2]

[Miles Bader]

Index: emacs/lisp/international/mule-cmds.el
diff -c emacs/lisp/international/mule-cmds.el:1.242.2.7 
emacs/lisp/international/mule-cmds.el:1.242.2.8
*** emacs/lisp/international/mule-cmds.el:1.242.2.7     Tue Oct  5 23:16:10 2004
--- emacs/lisp/international/mule-cmds.el       Fri Nov 12 02:52:54 2004
***************
*** 1,7 ****
  ;;; mule-cmds.el --- commands for mulitilingual environment -*-coding: 
iso-2022-7bit -*-
  ;; Copyright (C) 1995, 2003 Electrotechnical Laboratory, JAPAN.
! ;;   Licensed to the Free Software Foundation.
! ;; Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
  ;; Copyright (C) 2003
  ;;   National Institute of Advanced Industrial Science and Technology (AIST)
  ;;   Registration Number H13PRO009
--- 1,8 ----
  ;;; mule-cmds.el --- commands for mulitilingual environment -*-coding: 
iso-2022-7bit -*-
+ 
+ ;; Copyright (C) 2000, 2001, 2002, 2003, 2004  Free Software Foundation, Inc.
  ;; Copyright (C) 1995, 2003 Electrotechnical Laboratory, JAPAN.
! ;; Licensed to the Free Software Foundation.
  ;; Copyright (C) 2003
  ;;   National Institute of Advanced Industrial Science and Technology (AIST)
  ;;   Registration Number H13PRO009
***************
*** 611,616 ****
--- 612,786 ----
  function `select-safe-coding-system' (which see).  This variable
  overrides that argument.")
  
+ (defun select-safe-coding-system-interactively (from to codings unsafe
+                                               &optional rejected default)
+   "Select interactively a coding system for the region FROM ... TO.
+ FROM can be a string, as in `write-region'.
+ CODINGS is the list of base coding systems known to be safe for this region,
+   typically obtained with `find-coding-systems-region'.
+ UNSAFE is a list of coding systems known to be unsafe for this region.
+ REJECTED is a list of coding systems which were safe but for some reason
+   were not recommended in the particular context.
+ DEFAULT is the coding system to use by default in the query."
+   ;; At first, if some defaults are unsafe, record at most 11
+   ;; problematic characters and their positions for them by turning
+   ;;  (CODING ...)
+   ;; into
+   ;;  ((CODING (POS . CHAR) (POS . CHAR) ...) ...)
+   (if unsafe
+       (setq unsafe
+           (mapcar #'(lambda (coding)
+                       (cons coding
+                             (if (stringp from)
+                                 (mapcar #'(lambda (pos)
+                                             (cons pos (aref from pos)))
+                                         (unencodable-char-position
+                                          0 (length from) coding
+                                          11 from))
+                               (mapcar #'(lambda (pos)
+                                           (cons pos (char-after pos)))
+                                       (unencodable-char-position
+                                        from to coding 11)))))
+                   unsafe)))
+ 
+   ;; Change each safe coding system to the corresponding
+   ;; mime-charset name if it is also a coding system.  Such a name
+   ;; is more friendly to users.
+   (let ((l codings)
+       mime-charset)
+     (while l
+       (setq mime-charset (coding-system-get (car l) 'mime-charset))
+       (if (and mime-charset (coding-system-p mime-charset))
+         (setcar l mime-charset))
+       (setq l (cdr l))))
+ 
+   ;; Don't offer variations with locking shift, which you
+   ;; basically never want.
+   (let (l)
+     (dolist (elt codings (setq codings (nreverse l)))
+       (unless (or (eq 'coding-category-iso-7-else
+                     (coding-system-category elt))
+                 (eq 'coding-category-iso-8-else
+                     (coding-system-category elt)))
+       (push elt l))))
+ 
+   ;; Remove raw-text, emacs-mule and no-conversion unless nothing
+   ;; else is available.
+   (setq codings
+       (or (delq 'raw-text
+                 (delq 'emacs-mule
+                       (delq 'no-conversion codings)))
+           '(raw-text emacs-mule no-conversion)))
+ 
+   (let ((window-configuration (current-window-configuration))
+       (bufname (buffer-name))
+       coding-system)
+     (save-excursion
+       ;; If some defaults are unsafe, make sure the offending
+       ;; buffer is displayed.
+       (when (and unsafe (not (stringp from)))
+       (pop-to-buffer bufname)
+       (goto-char (apply 'min (mapcar #'(lambda (x) (car (cadr x)))
+                                      unsafe))))
+       ;; Then ask users to select one from CODINGS while showing
+       ;; the reason why none of the defaults are not used.
+       (with-output-to-temp-buffer "*Warning*"
+       (with-current-buffer standard-output
+         (if (and (null rejected) (null unsafe))
+             (insert "No default coding systems to try for "
+                     (if (stringp from)
+                         (format "string \"%s\"." from)
+                       (format "buffer `%s'." bufname)))
+           (insert
+            "These default coding systems were tried to encode"
+            (if (stringp from)
+                (concat " \"" (if (> (length from) 10)
+                                  (concat (substring from 0 10) "...\"")
+                                (concat from "\"")))
+              (format " text\nin the buffer `%s'" bufname))
+            ":\n")
+           (let ((pos (point))
+                 (fill-prefix "  "))
+             (dolist (x (append rejected unsafe))
+               (princ "  ") (princ (car x)))
+             (insert "\n")
+             (fill-region-as-paragraph pos (point)))
+           (when rejected
+             (insert "These safely encodes the target text,
+ but it is not recommended for encoding text in this context,
+ e.g., for sending an email message.\n ")
+             (dolist (x rejected)
+               (princ " ") (princ x))
+             (insert "\n"))
+           (when unsafe
+             (insert (if rejected "And the others"
+                       "However, each of them")
+                     " encountered these problematic characters:\n")
+             (dolist (coding unsafe)
+               (insert (format "  %s:" (car coding)))
+               (let ((i 0)
+                     (func1
+                      #'(lambda (bufname pos)
+                          (when (buffer-live-p (get-buffer bufname))
+                            (pop-to-buffer bufname)
+                            (goto-char pos))))
+                     (func2
+                      #'(lambda (bufname pos coding)
+                          (when (buffer-live-p (get-buffer bufname))
+                            (pop-to-buffer bufname)
+                            (if (< (point) pos)
+                                (goto-char pos)
+                              (forward-char 1)
+                              (search-unencodable-char coding)
+                              (forward-char -1))))))
+                 (dolist (elt (cdr coding))
+                   (insert " ")
+                   (if (stringp from)
+                       (insert (if (< i 10) (cdr elt) "..."))
+                     (if (< i 10)
+                         (insert-text-button
+                          (cdr elt)
+                          :type 'help-xref
+                          'help-echo
+                          "mouse-2, RET: jump to this character"
+                          'help-function func1
+                          'help-args (list bufname (car elt)))
+                       (insert-text-button
+                        "..."
+                        :type 'help-xref
+                        'help-echo
+                        "mouse-2, RET: next unencodable character"
+                        'help-function func2
+                        'help-args (list bufname (car elt)
+                                         (car coding)))))
+                   (setq i (1+ i))))
+               (insert "\n"))
+             (insert "\
+ The first problematic character is at point in the displayed buffer,\n"
+                     (substitute-command-keys "\
+ and \\[universal-argument] \\[what-cursor-position] will give information 
about it.\n"))))
+         (insert "\nSelect \
+ one of the following safe coding systems, or edit the buffer:\n")
+         (let ((pos (point))
+               (fill-prefix "  "))
+           (dolist (x codings)
+             (princ "  ") (princ x))
+           (insert "\n")
+           (fill-region-as-paragraph pos (point)))
+         (insert "Or specify any other coding system
+ at the risk of losing the problematic characters.\n")))
+ 
+       ;; Read a coding system.
+       (setq coding-system
+           (read-coding-system
+            (format "Select coding system (default %s): " default)
+            default))
+       (setq last-coding-system-specified coding-system))
+ 
+     (kill-buffer "*Warning*")
+     (set-window-configuration window-configuration)
+     coding-system))
+ 
  (defun select-safe-coding-system (from to &optional default-coding-system
                                       accept-default-p file)
    "Ask a user to select a safe coding system from candidates.
***************
*** 705,711 ****
  
    (let ((codings (find-coding-systems-region from to))
        (coding-system nil)
-       (bufname (buffer-name))
        safe rejected unsafe)
      ;; Classify the defaults into safe, rejected, and unsafe.
      (dolist (elt default-coding-system)
--- 875,880 ----
***************
*** 1344,1355 ****
              current-input-method-title nil)
        (force-mode-line-update)))))
  
! (defun set-input-method (input-method)
    "Select and activate input method INPUT-METHOD for the current buffer.
  This also sets the default input method to the one you specify.
  If INPUT-METHOD is nil, this function turns off the input method, and
  also causes you to be prompted for a name of an input method the next
  time you invoke \\[toggle-input-method].
  
  To deactivate the input method interactively, use \\[toggle-input-method].
  To deactivate it programmatically, use \\[inactivate-input-method]."
--- 1513,1526 ----
              current-input-method-title nil)
        (force-mode-line-update)))))
  
! (defun set-input-method (input-method &optional interactive)
    "Select and activate input method INPUT-METHOD for the current buffer.
  This also sets the default input method to the one you specify.
  If INPUT-METHOD is nil, this function turns off the input method, and
  also causes you to be prompted for a name of an input method the next
  time you invoke \\[toggle-input-method].
+ When called interactively, the optional arg INTERACTIVE is non-nil,
+ which marks the variable `default-input-method' as set for Custom buffers.
  
  To deactivate the input method interactively, use \\[toggle-input-method].
  To deactivate it programmatically, use \\[inactivate-input-method]."
***************
*** 1357,1370 ****
     (let* ((default (or (car input-method-history) default-input-method)))
       (list (read-input-method-name
            (if default "Select input method (default %s): " "Select input 
method: ")
!           default t))))
    (activate-input-method input-method)
    (setq default-input-method input-method)
!   (when (interactive-p)
      (customize-mark-as-set 'default-input-method))
    default-input-method)
  
! (defun toggle-input-method (&optional arg)
    "Enable or disable multilingual text input method for the current buffer.
  Only one input method can be enabled at any time in a given buffer.
  
--- 1528,1542 ----
     (let* ((default (or (car input-method-history) default-input-method)))
       (list (read-input-method-name
            (if default "Select input method (default %s): " "Select input 
method: ")
!           default t)
!          t)))
    (activate-input-method input-method)
    (setq default-input-method input-method)
!   (when interactive
      (customize-mark-as-set 'default-input-method))
    default-input-method)
  
! (defun toggle-input-method (&optional arg interactive)
    "Enable or disable multilingual text input method for the current buffer.
  Only one input method can be enabled at any time in a given buffer.
  
***************
*** 1377,1385 ****
  
  With a prefix argument, read an input method name with the minibuffer
  and enable that one.  The default is the most recent input method specified
! \(not including the currently active input method, if any)."
  
!   (interactive "P")
    (if (and current-input-method (not arg))
        (inactivate-input-method)
      (let ((default (or (car input-method-history) default-input-method)))
--- 1549,1560 ----
  
  With a prefix argument, read an input method name with the minibuffer
  and enable that one.  The default is the most recent input method specified
! \(not including the currently active input method, if any).
  
! When called interactively, the optional arg INTERACTIVE is non-nil,
! which marks the variable `default-input-method' as set for Custom buffers."
! 
!   (interactive "P\np")
    (if (and current-input-method (not arg))
        (inactivate-input-method)
      (let ((default (or (car input-method-history) default-input-method)))
***************
*** 1396,1402 ****
        (unless default-input-method
        (prog1
            (setq default-input-method current-input-method)
!         (when (interactive-p)
            (customize-mark-as-set 'default-input-method)))))))
  
  (eval-when-compile (autoload 'help-buffer "help-mode"))
--- 1571,1577 ----
        (unless default-input-method
        (prog1
            (setq default-input-method current-input-method)
!         (when interactive
            (customize-mark-as-set 'default-input-method)))))))
  
  (eval-when-compile (autoload 'help-buffer "help-mode"))
***************
*** 2545,2549 ****
  (defvar nonascii-translation-table nil "This variable is obsolete.")
  
  
! ;;; arch-tag: b382c432-4b36-460e-bf4c-05efd0bb18dc
  ;;; mule-cmds.el ends here
--- 2720,2724 ----
  (defvar nonascii-translation-table nil "This variable is obsolete.")
  
  
! ;; arch-tag: b382c432-4b36-460e-bf4c-05efd0bb18dc
  ;;; mule-cmds.el ends here