From: Kenichi Handa <handa@m17n.org>
Date: Wed, 28 May 1997 03:37:32 +0000 (+0000)
Subject: Delete defining "i" in mule-keymap.
X-Git-Tag: emacs-20.1~1955
X-Git-Url: https://code.delx.au/gnu-emacs/commitdiff_plain/15b3e511e117d0c07a28afd0c40596a631a28e4f

Delete defining "i" in mule-keymap.
(mule-menu-keymap): New variable.  All menu items related to mule
are defined in this keymap.
(set-language-info): Change format of INFO for KEY documentation
and setup-function.
(setup-specified-language-environment): New function.
(setup-language-environment): Call the above function.
(describe-specified-language-support): New function.
(describe-language-support): Call the above function.
(universal-coding-system-argument): New function.
(read-language-and-input-method-name): Doc-string fixed.  If
default-input-method is nil, use previous-input-method as the
default value.
(set-default-input-method): Deleted.
---

diff --git a/lisp/international/mule-cmds.el b/lisp/international/mule-cmds.el
index b846679667..1aaea1d48f 100644
--- a/lisp/international/mule-cmds.el
+++ b/lisp/international/mule-cmds.el
@@ -26,78 +26,104 @@
 
 ;;; MULE related key bindings and menus.
 
-(defvar mule-keymap (make-sparse-keymap "MULE")
+(defvar mule-keymap nil
   "Keymap for MULE (Multilingual environment) specific commands.")
-(fset 'mule-prefix mule-keymap)
+(define-prefix-command 'mule-keymap)
 
 ;; Keep "C-x C-m ..." for mule specific commands.
-(define-key ctl-x-map "\C-m" 'mule-prefix)
-
-(define-key global-map [menu-bar mule] (cons "Mule" mule-keymap))
-
-(setq menu-bar-final-items (cons 'mule menu-bar-final-items))
-
-(defvar mule-describe-language-support-map
-  (make-sparse-keymap "Describe Language Support"))
-(fset 'mule-describe-language-support-prefix
-      mule-describe-language-support-map)
-
-(defvar mule-set-language-environment-map
-  (make-sparse-keymap "Set Language Environment"))
-(fset 'mule-set-language-environment-prefix
-      mule-set-language-environment-map)
+(define-key ctl-x-map "\C-m" 'mule-keymap)
 
 (define-key mule-keymap "m" 'toggle-enable-multibyte-characters)
 (define-key mule-keymap "f" 'set-buffer-file-coding-system)
 (define-key mule-keymap "t" 'set-terminal-coding-system)
-(define-key mule-keymap "k" 'encoded-kbd-set-coding-system)
-(define-key mule-keymap "p" 'set-current-process-coding-system)
-(define-key mule-keymap "i" 'select-input-method)
+(define-key mule-keymap "k" 'set-keyboard-coding-system)
+(define-key mule-keymap "p" 'set-buffer-process-coding-system)
 (define-key mule-keymap "\C-\\" 'select-input-method)
+(define-key mule-keymap "c" 'universal-coding-system-argument)
 
 (define-key help-map "\C-L" 'describe-language-support)
 (define-key help-map "\C-\\" 'describe-input-method)
 (define-key help-map "C" 'describe-current-coding-system)
 (define-key help-map "h" 'view-hello-file)
 
-(define-key mule-keymap [view-hello-file]
-  '("Show many languages" . view-hello-file))
-(define-key mule-keymap [mule-diag]
-  '("Show diagnosis for MULE" . mule-diag))
-(define-key mule-keymap [separator-coding-system]
-  '("--"))
-(define-key mule-keymap [set-process-coding-system]
-  '("Set coding system of process" . set-current-process-coding-system))
-(define-key mule-keymap [encoded-kbd-set-coding-system]
-  '("Set coding system for Encoded-kbd mode" . encoded-kbd-set-coding-system))
-(define-key mule-keymap [set-terminal-coding-system]
-  '("Set coding system of terminal" . set-terminal-coding-system))
-(define-key mule-keymap [set-buffer-file-coding-system]
-  '("Set coding system of buffer file" . set-buffer-file-coding-system))
-(define-key mule-keymap [describe-current-coding-system]
-  '("Describe current coding systems" . describe-current-coding-system))
-(define-key mule-keymap [separator-input-method]
-  '("--"))
-(define-key mule-keymap [describe-input-method]
-  '("Describe input method" . describe-input-method))
-(define-key mule-keymap [select-input-method]
-  '("Select input method" . select-input-method))
-(define-key mule-keymap [toggle-input-method]
-  '("Toggle input method" . toggle-input-method))
-(define-key mule-keymap [separator-mule]
-  '("--"))
-(define-key mule-keymap [set-language-environment]
-  '("Set language environment" . mule-set-language-environment-prefix))
-(define-key mule-keymap [describe-language-support]
-  '("Describe language support" . mule-describe-language-support-prefix))
-(define-key mule-keymap [toggle-mule]
-  '("Disable/enable multibyte character" . toggle-enable-multibyte-characters))
+(defvar mule-menu-keymap nil
+  "Keymap for MULE (Multilingual environment) menu specific commands.")
+(define-prefix-command 'mule-menu-keymap)
+
+(define-key global-map [menu-bar mule] (cons "Mule" mule-menu-keymap))
+
+(setq menu-bar-final-items (cons 'mule menu-bar-final-items))
+
+(defvar describe-language-support-map nil)
+(define-prefix-command 'describe-language-support-map)
+
+(defvar setup-language-environment-map nil)
+(define-prefix-command 'setup-language-environment-map)
+
+(defvar set-coding-system-map nil)
+(define-prefix-command 'set-coding-system-map)
+
+(define-key-after mule-menu-keymap [toggle-mule]
+  '("Toggle MULE facility" . toggle-enable-multibyte-characters)
+  t)
+(define-key-after mule-menu-keymap [describe-language-support]
+  '("Describe language support" . describe-language-support-map)
+  t)
+(define-key-after mule-menu-keymap [set-language-environment]
+  '("Set language environment" . setup-language-environment-map)
+  t)
+(define-key-after mule-menu-keymap [separator-mule]
+  '("--")
+  t)
+(define-key-after mule-menu-keymap [toggle-input-method]
+  '("Toggle input method" . toggle-input-method)
+  t)
+(define-key-after mule-menu-keymap [select-input-method]
+  '("Select input method" . select-input-method)
+  t)
+(define-key-after mule-menu-keymap [describe-input-method]
+  '("Describe input method" . describe-input-method)
+  t)
+(define-key-after mule-menu-keymap [separator-input-method]
+  '("--")
+  t)
+(define-key-after mule-menu-keymap [describe-current-coding-system]
+  '("Describe coding systems" . describe-current-coding-system)
+  t)
+(define-key-after mule-menu-keymap [set-various-coding-system]
+  '("Set coding systems" . set-coding-system-map)
+  t)
+(define-key-after mule-menu-keymap [separator-coding-system]
+  '("--")
+  t)
+(define-key-after mule-menu-keymap [mule-diag]
+  '("Show diagnosis for MULE" . mule-diag)
+  t)
+(define-key-after mule-menu-keymap [view-hello-file]
+  '("Show many languages" . view-hello-file)
+  t)
+
+(define-key-after set-coding-system-map [set-buffer-file-coding-system]
+  '("Buffer file" . set-buffer-file-coding-system)
+  t)
+(define-key-after set-coding-system-map [set-terminal-coding-system]
+  '("Terminal" . set-terminal-coding-system)
+  t)
+(define-key-after set-coding-system-map [set-keyboard-coding-system]
+  '("Keyboard" . set-keyboard-coding-system)
+  t)
+(define-key-after set-coding-system-map [set-buffer-process-coding-system]
+  '("Buffer process" . set-buffer-process-coding-system)
+  t)
+
+(define-key setup-language-environment-map
+  [Default] '("Default" . setup-specified-language-environment))
 
 ;; These are meaningless when running under X.
-(put 'encoded-kbd-set-coding-system 'menu-enable
-     '(null window-system))
 (put 'set-terminal-coding-system 'menu-enable
      '(null window-system))
+(put 'set-keyboard-coding-system 'menu-enable
+     '(null window-system))
 
 ;; This should be a single character key binding because users use it
 ;; very frequently while editing multilingual text.  Now we can use
@@ -124,6 +150,18 @@ With arg, make them enable iff arg is positive."
 	(coding-system-for-read 'iso-2022-7))
     (find-file-read-only (expand-file-name "HELLO" data-directory))))
 
+(defun universal-coding-system-argument ()
+  "Execute an I/O command using the specified coding system."
+  (interactive)
+  (let* ((coding-system (read-coding-system "Coding system: "))
+	 (keyseq (read-key-sequence
+		  (format "With coding system %s:" coding-system)))
+	 (cmd (key-binding keyseq)))
+    (let ((coding-system-for-read coding-system)
+	  (coding-system-for-write coding-system))
+      (message "")
+      (call-interactively cmd))))
+
 
 ;;; Language support staffs.
 
@@ -144,8 +182,7 @@ to KEY.")
   "Return the information for LANGUAGE-NAME of the kind KEY.
 LANGUAGE-NAME is a string.
 KEY is a symbol denoting the kind of required information."
-  (let ((lang-slot (assoc-ignore-case
-		    (downcase language-name) language-info-alist)))
+  (let ((lang-slot (assoc-ignore-case language-name language-info-alist)))
     (if lang-slot
 	(cdr (assq key (cdr lang-slot))))))
 
@@ -163,16 +200,22 @@ sample-text: one line short text containing characters of the language.
 input-method: alist of input method names for the language vs information
   for activating them.  Use `register-input-method' (which see)
   to add a new input method to the alist.
-documentation: a string describing how Emacs supports the language,
-  or a list of a string, or t.  In the latter two cases,
-  the other detailed information is also shown by the command
-  describe-language-support.
+documentation: t or a string describing how Emacs supports the language.
+  If a string is specified, it is shown before any other information
+  of the language by the command describe-language-support.
 setup-function: a function to call for setting up environment
- convenient for the language.
+ convenient for a user of the language.
+
+If KEY is documentation or setup-function, you can also specify
+a cons cell as INFO, in which case, the car part should be
+a normal value as INFO for KEY (as described above),
+and the cdr part should be a symbol whose value is a menu keymap
+in which an entry for the language is defined.  But, only the car part
+is actually set as the information.
 
 Emacs will use more KEYs in the future.  To avoid conflict, users
 should use prefix \"user-\" in the name of KEY if he wants to set
-different kind of information."
+different kind of information for personal use."
   (let (lang-slot key-slot)
     (setq lang-slot (assoc language-name language-info-alist))
     (if (null lang-slot)		; If no slot for the language, add it.
@@ -183,18 +226,27 @@ different kind of information."
 	(progn
 	  (setq key-slot (list key))
 	  (setcdr lang-slot (cons key-slot (cdr lang-slot)))))
-    (setcdr key-slot info)
     ;; Setup menu.
     (cond ((eq key 'documentation)
-	   (define-key-after mule-describe-language-support-map
+	   (define-key-after
+	     (if (consp info)
+		 (prog1 (symbol-value (cdr info))
+		   (setq info (car info)))
+	       describe-language-support-map)
 	     (vector (intern language-name))
 	     (cons language-name 'describe-specified-language-support)
 	     t))
 	  ((eq key 'setup-function)
-	   (define-key-after mule-set-language-environment-map
+	   (define-key-after
+	     (if (consp info)
+		 (prog1 (symbol-value (cdr info))
+		   (setq info (car info)))
+	       setup-language-environment-map)
 	     (vector (intern language-name))
-	     (cons language-name info)
+	     (cons language-name 'setup-specified-language-environment)
 	     t)))
+
+    (setcdr key-slot info)
     ))
 
 (defun set-language-info-alist (language-name alist)
@@ -237,14 +289,20 @@ Every input method should set this to an appropriate value when activated.")
 The default input method is the one activated automatically by the command
 `toggle-input-method' (\\[toggle-input-method]).
 The value is a cons of language name and input method name.")
+(make-variable-buffer-local 'default-input-method)
+(put 'default-input-method 'permanent-local t)
 
 (defvar default-input-method-title nil
   "Title string of the default input method.")
+(make-variable-buffer-local 'default-input-method-title)
+(put 'default-input-method-title 'permanent-local t)
 
 (defvar previous-input-method nil
   "Input method selected previously.
 This is the one selected before the current input method is selected.
 See also the documentation of `default-input-method'.")
+(make-variable-buffer-local 'previous-input-method)
+(put 'previous-input-method 'permanent-local t)
 
 (defvar inactivate-current-input-method-function nil
   "Function to call for inactivating the current input method.
@@ -278,43 +336,60 @@ Arguments for the function are METHOD-NAME and ARGs."
 			   (cons input-method slot))))))
 
 (defun read-language-and-input-method-name ()
-  "Read a language names and the corresponding input method from a minibuffer.
-Return a cons of those names."
-  (let ((language-name (read-language-name
-			'input-method
-			"Language: "
-			(if previous-input-method
-			    (cons (car previous-input-method) 0)))))
+  "Read a language name and the corresponding input method from a minibuffer.
+Return a list of those names."
+  (let* ((default-val (or previous-input-method default-input-method))
+	 (language-name (read-language-name
+			 'input-method "Language: "
+			 (if default-val (cons (car default-val) 0)))))
     (if (null language-name)
 	(error "No input method for the specified language"))
+    (if (not (string= language-name (car default-val)))
+	;; Now the default value has no meaning.
+	(setq default-val nil))
     (let* ((completion-ignore-case t)
 	   (key-slot (cdr (assq 'input-method
 				(assoc language-name language-info-alist))))
 	   (method-name
 	    (completing-read "Input method: " key-slot nil t
-			     (if (and previous-input-method
-				      (string= language-name
-					       (car previous-input-method)))
-				 (cons (cdr previous-input-method) 0)))))
+			     (if default-val (cons (cdr default-val) 0)))))
       (if (= (length method-name) 0)
 	  (error "No input method specified"))
       (list language-name
-	    (car (assoc-ignore-case (downcase method-name) key-slot))))))
-
-(defun set-default-input-method (language-name method-name)
-  "Set the default input method to METHOD-NAME for inputting LANGUAGE-NAME.
-The default input method is the one activated automatically by the command
-`toggle-input-method' (\\[toggle-input-method]).
-This doesn't affect the currently activated input method."
-  (interactive (read-language-and-input-method-name))
-  (let* ((key-slot (get-language-info language-name 'input-method))
-	 (method-slot (assoc method-name key-slot)))
-    (if (null method-slot)
-	(error "No input method `%s' for %s" method-name language-name))
-    (setq default-input-method (cons language-name method-name))))
+	    (car (assoc-ignore-case method-name key-slot))))))
+
+;; Actvate input method METHOD-NAME for langauge LANGUAGE-NAME.
+(defun activate-input-method (language-name method-name)
+  (if (and current-input-method
+	   (or (not (string= (car current-input-method) language-name))
+	       (not (string= (cdr current-input-method) method-name))))
+      (inactivate-input-method))
+  (or current-input-method
+      (let* ((key-slot (get-language-info language-name 'input-method))
+	     (method-slot (cdr (assoc method-name key-slot))))
+	(if (null method-slot)
+	    (error "Invalid input method `%s' for  %s"
+		   method-name language-name))
+	(apply (car method-slot) method-name (cdr method-slot))
+	(setq current-input-method (cons language-name method-name))
+	(if (not (equal default-input-method current-input-method))
+	    (progn
+	      (setq previous-input-method default-input-method)
+	      (setq default-input-method current-input-method)
+	      (setq default-input-method-title current-input-method-title))))))
+
+;; Inactivate the current input method.
+(defun inactivate-input-method ()
+  (if current-input-method
+      (unwind-protect
+	  (funcall inactivate-current-input-method-function)
+	(setq current-input-method nil))))
 
 (defun select-input-method (language-name method-name)
   "Select and activate input method METHOD-NAME for inputting LANGUAGE-NAME.
+Both the default and local values of default-input-method are
+set to the selected input method.
+
 The information for activating METHOD-NAME is stored
 in `language-info-alist' under the key 'input-method.
 The format of the information has the form:
@@ -322,38 +397,28 @@ The format of the information has the form:
 where ACTIVATE-FUNC is a function to call for activating this method.
 Arguments for the function are METHOD-NAME and ARGs."
   (interactive (read-language-and-input-method-name))
-  (let* ((key-slot (get-language-info language-name 'input-method))
-	 (method-slot (assoc method-name key-slot)))
-    (if (null method-slot)
-	(error "No input method `%s' for %s" method-name language-name))
-    (if current-input-method
-	(progn
-	  (setq previous-input-method current-input-method)
-	  (unwind-protect
-	      (funcall inactivate-current-input-method-function)
-	    (setq current-input-method nil))))
-    (setq method-slot (cdr method-slot))
-    (apply (car method-slot) method-name (cdr method-slot))
-    (setq default-input-method
-	  (setq current-input-method (cons language-name method-name)))
-    (setq default-input-method-title current-input-method-title)
-    (setq current-input-method default-input-method)))
+  (activate-input-method language-name method-name)
+  (setq-default default-input-method default-input-method)
+  (setq-default default-input-method-title default-input-method-title))
 
 (defun toggle-input-method (&optional arg)
-  "Toggle whether a multilingual input method is activated in this buffer.
-With arg, activate an input method specified interactively.
-Without arg, the method being activated is the one selected most recently,
- but if no input method has ever been selected, select one interactively."
+  "Turn on or off a multilingual text input method for the current buffer.
+With arg, turn on an input method specified interactively.
+Without arg, if some input method is currently activated, turn it off,
+else turn on default-input-method (which see).
+In the latter case, if default-input-method is nil, select an input method
+interactively."
   (interactive "P")
   (if arg
-      (call-interactively 'select-input-method)
-    (if (null current-input-method)
-	(if default-input-method
-	    (select-input-method (car default-input-method)
+      (let ((input-method (read-language-and-input-method-name)))
+	(activate-input-method (car input-method) (nth 1 input-method)))
+    (if current-input-method
+	(inactivate-input-method)
+      (if default-input-method
+	  (activate-input-method (car default-input-method)
 				 (cdr default-input-method))
-	  (call-interactively 'select-input-method))
-      (funcall inactivate-current-input-method-function)
-      (setq current-input-method nil))))
+	(let ((input-method (read-language-and-input-method-name)))
+	  (activate-input-method (car input-method) (nth 1 input-method)))))))
 
 (defun describe-input-method ()
   "Describe the current input method."
@@ -372,14 +437,19 @@ Without arg, the method being activated is the one selected most recently,
 					language-name method-name)
   "Read a multilingual string from minibuffer, prompting with string PROMPT.
 The input method selected last time is activated in minibuffer.
-If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
+If optional second arg INITIAL-INPUT is non-nil, insert it in the minibuffer
+ initially
 Optional 3rd and 4th arguments LANGUAGE-NAME and METHOD-NAME specify
  the input method to be activated instead of the one selected last time."
-  (let ((minibuffer-setup-hook '(toggle-input-method))
-	(default-input-method default-input-method))
+  (let ((default-input-method default-input-method))
     (if (and language-name method-name)
-	(set-default-input-method language-name method-name))
-    (read-string prompt initial-input)))
+	(setq default-input-method (cons language-name method-name))
+      (or default-input-method
+	  (let ((lang-and-input-method (read-language-and-input-method-name)))
+	    (setq default-input-method (cons (car lang-and-input-method)
+					     (nth 1 lang-and-input-method))))))
+    (let ((minibuffer-setup-hook '(toggle-input-method)))
+      (read-string prompt initial-input))))
 
 ;; Variables to control behavior of input methods.  All input methods
 ;; should react to these variables.
@@ -400,20 +470,28 @@ inputting at minibuffer if this flag is t.")
   "Normal hook run just after an input method insert some chunk of text.")
 
 
-;;; Language specific setup functions.
-(defun set-language-environment (language-name)
-  "Setup multilingual environment convenient for LANGUAGE-NAME.
+(defun setup-specified-language-environment ()
+  "Setup multi-lingual environment convenient for the specified language."
+  (interactive)
+  (let (language-name func)
+    (if (and (symbolp last-command-event)
+	     (or (not (eq last-command-event 'Default))
+		 (setq last-command-event 'English))
+	     (setq language-name (symbol-name last-command-event))
+	     (setq func (get-language-info language-name 'setup-function)))
+	(progn
+	  (funcall func)
+	  (force-mode-line-update t))
+      (error "Bogus calling sequence"))))
 
-For that, a fucntion returned by:
-  (get-language-info LANGUAGE-NAME 'setup-function)
-is called."
+(defun setup-language-environment (language-name)
+  "Setup multi-lingual environment convenient for LANGUAGE-NAME users."
   (interactive (list (read-language-name 'setup-function "Language: ")))
-  (let (func)
-    (if (or (null language-name)
-	    (null (setq func
-			(get-language-info language-name 'setup-function))))
-	(error "No way to setup environment for the specified language"))
-    (funcall func)))
+  (if (or (null language-name)
+	  (null (get-language-info language-name 'setup-function)))
+      (error "No way to setup environment for the specified language"))
+  (let ((last-command-event (intern language-name)))
+    (setup-specified-language-environment)))
 
 ;; Print all arguments with `princ', then print "\n".
 (defsubst princ-list (&rest args)
@@ -435,41 +513,38 @@ is called."
 	(error "Bogus calling sequence"))
     (with-output-to-temp-buffer "*Help*"
       (if (stringp doc)
-	  (princ-list doc)
-	(if (and (listp doc)
-		 (stringp (car doc)))
-	    (princ-list (car doc)))
-	(princ "-----------------------------------------------------------\n")
-	(princ-list "List of items specific to "
-		    language-name
-		    " support")
-	(princ "-----------------------------------------------------------\n")
-	(let ((str (get-language-info language-name 'sample-text)))
-	  (if (stringp str)
-	      (progn
-		(princ "<sample text>\n")
-		(princ-list "  " str))))
-	(princ "<input methods>\n")
-	(let ((l (get-language-info language-name 'input-method)))
+	  (princ-list doc))
+      (princ "-----------------------------------------------------------\n")
+      (princ-list "List of items specific to "
+		  language-name
+		  " support")
+      (princ "-----------------------------------------------------------\n")
+      (let ((str (get-language-info language-name 'sample-text)))
+	(if (stringp str)
+	    (progn
+	      (princ "<sample text>\n")
+	      (princ-list "  " str))))
+      (princ "<input methods>\n")
+      (let ((l (get-language-info language-name 'input-method)))
+	(while l
+	  (princ-list "  " (car (car l)))
+	  (setq l (cdr l))))
+      (princ "<character sets>\n")
+      (let ((l (get-language-info language-name 'charset)))
+	(if (null l)
+	    (princ-list "  nothing specific to " language-name)
+	  (while l
+	    (princ-list "  " (car l) ": "
+			(charset-description (car l)))
+	    (setq l (cdr l)))))
+      (princ "<coding systems>\n")
+      (let ((l (get-language-info language-name 'coding-system)))
+	(if (null l)
+	    (princ-list "  nothing specific to " language-name)
 	  (while l
-	    (princ-list "  " (car (car l)))
-	    (setq l (cdr l))))
-	(princ "<character sets>\n")
-	(let ((l (get-language-info language-name 'charset)))
-	  (if (null l)
-	      (princ-list "  nothing specific to " language-name)
-	    (while l
-	      (princ-list "  " (car l) ": "
-			  (charset-description (car l)))
-	      (setq l (cdr l)))))
-	(princ "<coding systems>\n")
-	(let ((l (get-language-info language-name 'coding-system)))
-	  (if (null l)
-	      (princ-list "  nothing specific to " language-name)
-	    (while l
-	      (princ-list "  " (car l) ":\n\t"
-			  (coding-system-docstring (car l)))
-	      (setq l (cdr l)))))))))
+	    (princ-list "  " (car l) ":\n\t"
+			(coding-system-docstring (car l)))
+	    (setq l (cdr l))))))))
 
 (defun describe-language-support (language-name)
   "Describe how Emacs supports LANGUAGE-NAME."