comparison lisp/international/quail.el @ 22765:7cf2c3800e8f

(quail-mode): This variable deleted. (quail-current-key): Make it buffer local. (quail-current-str, quail-current-translations): Likewise. (quail-reset-conversion-region): This variable deleted. (quail-use-package): Call quail-activate at the tail. (quail-translation-keymap, quail-simple-translation-keymap): Key bindings for quail-execute-non-quail-command deleted. (quail-conversion-keymap): Likewise. Add key bindings for quail-self-insert-command. (quail-delete-overlays): Chekc overlay-start for overlays before deleting them. (quail-mode): This function deleted. (quail-inactivate, quail-activate): New functions. (quail-saved-current-map, quail-saved-current-buffer): These variables deleted. (quail-toggle-mode-temporarily, quail-execute-non-quail-command): These functions deleted. (quail-exit-conversion-mode, quail-prefix-arg): These variables deleted. (quail-error): New error condition. (quail-error): New function. (quail-translating, quail-converting): New variables. (quail-input-method, quail-overlay-region-events): New function. (quail-start-translation): Completely re-written. (quail-start-translation-in-conversion-mode): This function deleted. (quail-start-conversion): New function. (quail-terminate-translation): Just set quail-translating to nil. (quail-update-translation): Put some events back to unread-input-method-events instead of unread-command-events. Call quail-error instead of error. (quail-self-insert-command): Adjusted for the change of quail-start-translation. (quail-next-translation): Don't call quail-execute-non-quail-command, instead, put an event back of unread-command-events. (quail-prev-translation, quail-next-translation-block, quail-prev-translation-block): Likewize. (quail-conversion-backward-char): Call quail-error instead of error. Set quail-translating to nil. (quail-conversion-forward-char): Likewize. (quail-conversion-delete-char): Call quail-error instead of error. If conversion region gets vacant, set quail-converting to nil. (quail-conversion-backward-delete-char): Likewize. (quail-no-conversion): Just set quail-converting to nil. (quail-mouse-choose-completion): Call quai-error instead of error. (quail-choose-completion-string): Likewize. (quail-help): Don't handle quail-mode-map.

22764:8543c4052dd2

;; A main window showing Quail guidance buffer.
(defvar quail-guidance-win nil)
(make-variable-buffer-local 'quail-guidance-win)

(defvar quail-mode nil
  "Non-nil if in Quail minor mode.")
(make-variable-buffer-local 'quail-mode)
(put 'quail-mode 'permanent-local t)

(defvar quail-overlay nil
  "Overlay which covers the current translation region of Quail.")
(make-variable-buffer-local 'quail-overlay)

(defvar quail-conv-overlay nil
  "Overlay which covers the text to be converted in Quail mode.")
(make-variable-buffer-local 'quail-conv-overlay)

(defvar quail-current-key nil
  "Current key for translation in Quail mode.")

(defvar quail-current-str nil
  "Currently selected translation of the current key.")

(defvar quail-current-translations nil
  "Cons of indices and vector of possible translations of the current key.
Indices is a list of (CURRENT START END BLOCK BLOCKS), where
CURRENT is an index of the current translation,
START and END are indices of the start and end of the current block,
BLOCK is the current block index,
BLOCKS is a number of  blocks of translation.")

(defvar quail-current-data nil
  "Any Lisp object holding information of current translation status.
When a key sequence is mapped to TRANS and TRANS is a cons
of actual translation and some Lisp object to be refered
for translating the longer key sequence, this variable is set
to that Lisp object.")
(make-variable-buffer-local 'quail-current-data)

;; A flag to control conversion region.  Normally nil, but if set to
;; t, it means we must start the new conversion region if new key to
;; be translated is input.
(defvar quail-reset-conversion-region nil)

;; Quail package handlers.

(defvar quail-package-alist nil
  "List of Quail packages.

LEIM is available from the same ftp directory as Emacs."))
		(error "Can't use the Quail package `%s'" package-name))
	    (setq libraries (cdr libraries))))))
  (quail-select-package package-name)
  (setq current-input-method-title (quail-title))
  (quail-mode 1))

(defun quail-inactivate ()
  "Turn off Quail input method."
  (interactive)
  (setq overriding-terminal-local-map nil)
  (quail-mode -1))

(or (assq 'quail-mode minor-mode-alist)
    (setq minor-mode-alist
	  (cons '(quail-mode " Quail") minor-mode-alist)))

(defvar quail-mode-map 
  (let ((map (make-keymap))
	(i ? ))
    (while (< i 127)
      (define-key map (char-to-string i) 'quail-start-translation)
      (setq i (1+ i)))
    (setq i 128)
    (while (< i 256)
      (define-key map (vector i) 'quail-start-translation)
      (setq i (1+ i)))
    map)
  "Keymap for Quail mode.")

(or (assq 'quail-mode minor-mode-map-alist)
    (setq minor-mode-map-alist
	  (cons (cons 'quail-mode quail-mode-map) minor-mode-map-alist)))

;; Since some Emacs Lisp programs (e.g. viper.el) make
;; minor-mode-map-alist buffer-local, we must be sure to register
;; quail-mode-map in default-value of minor-mode-map-alist.
(if (local-variable-p 'minor-mode-map-alist)
    (let ((map (default-value 'minor-mode-map-alist)))
      (or (assq 'quail-mode map)
	  (set-default 'minor-mode-map-alist (cons 'quail-mode map)))))

(defvar quail-translation-keymap
  (let ((map (make-keymap))
	(i 0))
    (while (< i ?\ )
      (define-key map (char-to-string i) 'quail-execute-non-quail-command)
      (setq i (1+ i)))
    (while (< i 127)
      (define-key map (char-to-string i) 'quail-self-insert-command)
      (setq i (1+ i)))
    (setq i 128)
    (while (< i 256)

    ;; any completion visible in the *Quail Completions* buffer.
    (define-key map [kp-enter] 'quail-select-current)
    (define-key map [mouse-2] 'quail-mouse-choose-completion)
    (define-key map [down-mouse-2] nil)
    (define-key map "\C-h" 'quail-translation-help)
;;; This interferes with handling of escape sequences on non-X terminals.
;;;    (define-key map "\e" '(keymap (t . quail-execute-non-quail-command)))
    (define-key map [?\C- ] 'quail-select-current)
    (define-key map [tab] 'quail-completion)
    (define-key map [delete] 'quail-delete-last-char)
    (define-key map [backspace] 'quail-delete-last-char)
    (let ((meta-map (make-sparse-keymap)))
      (define-key map (char-to-string meta-prefix-char) meta-map)
      (define-key map [escape] meta-map))
    (define-key map (vector meta-prefix-char t)
      'quail-execute-non-quail-command)
    ;; At last, define default key binding.
    (define-key map [t] 'quail-execute-non-quail-command)
    map)
  "Keymap used processing translation in complex Quail modes.
Only a few especially complex input methods use this map;
most use `quail-simple-translation-keymap' instead.
This map is activated while translation region is active.")

(defvar quail-simple-translation-keymap
  (let ((map (make-keymap))
	(i 0))
    (while (< i ?\ )
      (define-key map (char-to-string i) 'quail-execute-non-quail-command)
      (setq i (1+ i)))
    (while (< i 127)
      (define-key map (char-to-string i) 'quail-self-insert-command)
      (setq i (1+ i)))
    (define-key map "\177" 'quail-delete-last-char)
    (define-key map [delete] 'quail-delete-last-char)
    (define-key map [backspace] 'quail-delete-last-char)
;;; This interferes with handling of escape sequences on non-X terminals.
;;;    (define-key map "\e" '(keymap (t . quail-execute-non-quail-command)))
    (let ((meta-map (make-sparse-keymap)))
      (define-key map (char-to-string meta-prefix-char) meta-map)
      (define-key map [escape] meta-map))
    (define-key map (vector meta-prefix-char t)
      'quail-execute-non-quail-command)
    ;; At last, define default key binding.
    (define-key map [t]
      'quail-execute-non-quail-command)
    map)
  "Keymap used while processing translation in simple Quail modes.
A few especially complex input methods use `quail--translation-keymap' instead.
This map is activated while translation region is active.")

(defvar quail-conversion-keymap
  (let ((map (make-keymap))
	(i 0))
    (while (< i ?\ )
      (define-key map (char-to-string i) 'quail-execute-non-quail-command)
      (setq i (1+ i)))
    (while (< i 127)
      (define-key map (char-to-string i)
	'quail-start-translation-in-conversion-mode)
      (setq i (1+ i)))
    (setq i 128)
    (while (< i 256)
      (define-key map (vector i) 'quail-start-translation-in-conversion-mode)
      (setq i (1+ i)))
    (define-key map "\C-b" 'quail-conversion-backward-char)
    (define-key map "\C-f" 'quail-conversion-forward-char)
    (define-key map "\C-a" 'quail-conversion-beginning-of-region)
    (define-key map "\C-e" 'quail-conversion-end-of-region)
    (define-key map "\C-d" 'quail-conversion-delete-char)
    (define-key map "\C-h" 'quail-conversion-help)
;;; This interferes with handling of escape sequences on non-X terminals.
;;;    (define-key map "\e" '(keymap (t . quail-execute-non-quail-command)))
    (define-key map "\177" 'quail-conversion-backward-delete-char)
    (define-key map [delete] 'quail-conversion-backward-delete-char)
    (define-key map [backspace] 'quail-conversion-backward-delete-char)
    (let ((meta-map (make-sparse-keymap)))
      (define-key map (char-to-string meta-prefix-char) meta-map)
      (define-key map [escape] meta-map))
    (define-key map (vector meta-prefix-char t)
      'quail-execute-non-quail-command)
    ;; At last, define default key binding.
    (define-key map [t] 'quail-execute-non-quail-command)
    map)
  "Keymap used for processing conversion in Quail mode.
This map is activated while convesion region is active but translation
region is not active.")

	  (if input-method-highlight-flag
	      (overlay-put quail-conv-overlay 'face 'underline))))))

;; Delete overlays used in Quail mode.
(defun quail-delete-overlays ()
  (if (overlayp quail-overlay)
      (delete-overlay quail-overlay))
  (if (overlayp quail-conv-overlay)
      (delete-overlay quail-conv-overlay)))

;; Kill Quail guidance buffer.  Set in kill-buffer-hook.
(defun quail-kill-guidance-buf ()
  (if (buffer-live-p quail-guidance-buf)
      (kill-buffer quail-guidance-buf)))

(defun quail-mode (&optional arg)
  "Toggle Quail minor mode.
With arg, turn Quail mode on if and only if arg is positive.

In Quail mode, all printable characters are bound to
`quail-start-translation'.  This function checks if the current input
method will translate the last input key.  If not, the key is handled
out of Quail mode, i.e, in another activated minor mode or in the
current major mode.
\\{quail-mode-map}
Unlike the other minor modes, this is not an interactive function.
Use the commands \\[toggle-input-method] (`toggle-input-method') or
\\[set-input-method] (`set-input-method') which automatically turn on
Quail mode with an appropriate Quail package, or turn it off."
  (setq quail-mode
	(if (null arg) (null quail-mode)
	  (> (prefix-numeric-value arg) 0)))
  (if (null quail-mode)
      ;; Let's turn off Quail mode.
      (progn
	(quail-hide-guidance-buf)
	(quail-delete-overlays)
	(setq describe-current-input-method-function nil)
	(run-hooks 'quail-mode-exit-hook))
    ;; Let's turn on Quail mode.
    ;; At first, be sure that quail-mode is at the first element of
    ;; minor-mode-map-alist.
    (or (eq (car minor-mode-map-alist) 'quail-mode)
	(let ((l minor-mode-map-alist))
	  (while (cdr l)
	    (if (eq (car (cdr l)) 'quail-mode)
		(progn
		  (setcdr l (cdr (cdr l)))
		  (setq l nil))
	      (setq l (cdr l))))
	  (setq minor-mode-map-alist (cons 'quail-mode minor-mode-map-alist))))
    (if (null quail-current-package)
	;; Quail package is not yet selected.  Select one now.
	(let (name)
	  (if quail-package-alist
	      (setq name (car (car quail-package-alist)))
	    (setq quail-mode nil)
	    (error "No Quail package loaded"))
	  (quail-select-package name)))
    (setq inactivate-current-input-method-function 'quail-inactivate)
    (setq describe-current-input-method-function 'quail-help)
    (quail-delete-overlays)
    (quail-show-guidance-buf)
    ;; If we are in minibuffer, turn off the current input method
    ;; before exiting.
    (if (eq (selected-window) (minibuffer-window))
	(add-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer))
    (make-local-hook 'post-command-hook)
    (make-local-hook 'kill-buffer-hook)
    (add-hook 'kill-buffer-hook 'quail-kill-guidance-buf nil t)
    (run-hooks 'quail-mode-hook))
  (force-mode-line-update))

(defun quail-exit-from-minibuffer ()
  (inactivate-input-method)
  (if (<= (minibuffer-depth) 1)
      (remove-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer)))

(defvar quail-saved-current-map nil)
(defvar quail-saved-current-buffer nil)

;; Toggle Quail mode.  This function is added to `post-command-hook'
;; in Quail mode, to turn Quail mode temporarily off, or back on after
;; one non-Quail command.
(defun quail-toggle-mode-temporarily ()
  (if quail-mode
      ;; We are going to handle following events out of Quail mode.
      (setq quail-saved-current-buffer (current-buffer)
	    quail-saved-current-map overriding-terminal-local-map
	    quail-mode nil
	    overriding-terminal-local-map nil)
    ;; We have just executed one non-Quail command.  We don't need
    ;; this hook any more.
    (remove-hook 'post-command-hook 'quail-toggle-mode-temporarily t)
    (if (eq (current-buffer) quail-saved-current-buffer)
	;; We should go back to Quail mode only when the current input
	;; method was not turned off by the last command.
	(when current-input-method
	  (setq quail-mode t
		overriding-terminal-local-map quail-saved-current-map)
	  (if input-method-exit-on-invalid-key
	      (inactivate-input-method)))
      ;; The last command changed the current buffer, we should not go
      ;; back to Quail mode in this new buffer, but should turn on
      ;; Quail mode in the original buffer.
      (save-excursion
	(set-buffer quail-saved-current-buffer)
	(setq quail-mode t)
	(quail-delete-overlays)))))

(defun quail-execute-non-quail-command ()
  "Execute one non-Quail command out of Quail mode.
The current translation and conversion are terminated."
  (interactive)
  (let* ((key (this-command-keys))
	 (keylist (listify-key-sequence key)))
    (setq unread-command-events (append keylist unread-command-events)))
  (reset-this-command-lengths)
  (quail-terminate-translation)
  (quail-delete-overlays)
  (setq overriding-terminal-local-map nil)
  (if (buffer-live-p quail-guidance-buf)
      (save-excursion
	(set-buffer quail-guidance-buf)
	(erase-buffer)))
  (add-hook 'post-command-hook 'quail-toggle-mode-temporarily nil t))

;; Keyboard layout translation handlers.

;; Some Quail packages provide localized keyboard simulation which
;; requires a particular keyboard layout.  In this case, what we need

	      (progn
		(setcdr map (funcall (cdr map) key len))))
	  ))
    map))

;; If set to non-nil, exit conversion mode before starting new translation.
(defvar quail-exit-conversion-mode nil)

(defvar quail-prefix-arg nil)

(defun quail-start-translation (arg)
  "Start translating the typed character in Quail mode."
  (interactive "*p")
  (setq prefix-arg current-prefix-arg)
  (setq quail-prefix-arg arg)
  (setq unread-command-events
	(cons last-command-event unread-command-events))
  ;; Check the possibility of translating the last key.
  (if (and (integerp last-command-event)
	   (assq (if (quail-kbd-translate)
		     (quail-keyboard-translate last-command-event)
		   last-command-event)
		 (cdr (quail-map))))
      ;; Ok, we can start translation.
      (if (quail-conversion-keymap)
	  ;; We must start translation in conversion mode.
	  (setq quail-exit-conversion-mode nil
		overriding-terminal-local-map (quail-conversion-keymap))
	(quail-setup-overlays nil)
	(setq quail-current-key "")
	(setq overriding-terminal-local-map (quail-translation-keymap)))
    ;; Since the last event doesn't start any translation, handle it
    ;; out of Quail mode.  We come back to Quail mode later by setting
    ;; function `quail-toggle-mode-temporarily' in
    ;; `post-command-hook'.
    (add-hook 'post-command-hook 'quail-toggle-mode-temporarily nil t)))

(defsubst quail-point-in-conversion-region ()
  "Return non-nil value if the point is in conversion region of Quail mode."
  (let (start pos)
    (and (setq start (overlay-start quail-conv-overlay))
	 (>= (setq pos (point)) start)
	 (<= pos (overlay-end quail-conv-overlay)))))

(defun quail-start-translation-in-conversion-mode ()
  "Start translating the typed character in conversion mode of Quail mode."
  (interactive "*")
  (setq unread-command-events
	(cons last-command-event unread-command-events))
  ;; Check the possibility of translating the last key.
  (if (and (integerp last-command-event)
	   (assq (if (quail-kbd-translate)
		     (quail-keyboard-translate last-command-event)
		   last-command-event)
		 (cdr (quail-map))))
      ;; Ok, we can start translation.
      (progn
	(quail-setup-overlays t)
	(setq quail-current-key "")
	(setq overriding-terminal-local-map (quail-translation-keymap))
	(move-overlay quail-overlay (point) (point)))
    ;; Since the last event doesn't start any translation, handle it
    ;; out of Quail mode.  We come back to Quail mode later by setting
    ;; function `quail-toggle-mode-temporarily' in
    ;; `post-command-hook'.
    (add-hook 'post-command-hook 'quail-toggle-mode-temporarily nil t)))

(defsubst quail-delete-region ()
  "Delete the text in the current translation region of Quail."
  (if (overlay-start quail-overlay)
      (delete-region (overlay-start quail-overlay)
		     (overlay-end quail-overlay))))

(defun quail-terminate-translation ()
  "Terminate the translation of the current key."
  (when (overlayp quail-overlay)
    (let ((start (overlay-start quail-overlay)))
      (if (and start
	       (< start (overlay-end quail-overlay)))
	  ;; Here we simulate self-insert-command.
	  (let ((seq (string-to-sequence
		      (buffer-substring (overlay-start quail-overlay)
					(overlay-end quail-overlay))
		      'list))
		last-command-char)
	    (goto-char start)
	    (quail-delete-region)
	    (setq last-command-char (car seq))
	    (self-insert-command (or quail-prefix-arg 1))
	    (setq quail-prefix-arg nil)
	    (setq seq (cdr seq))
	    (while seq
	      (setq last-command-char (car seq))
	      (self-insert-command 1)
	      (setq seq (cdr seq))))))
    (delete-overlay quail-overlay))
  (if (buffer-live-p quail-guidance-buf)
      (save-excursion
	(set-buffer quail-guidance-buf)
	(erase-buffer)))
  (setq overriding-terminal-local-map
	(quail-conversion-keymap))
  ;; Run this hook only when the current input method doesn't require
  ;; conversion.  When conversion is required, the conversion function
  ;; should run this hook at a proper timing.
  (unless (quail-conversion-keymap)
    (run-hooks 'input-method-after-insert-chunk-hook)))

(defun quail-select-current ()
  "Select the current text shown in Quail translation region."
  (interactive)
  (quail-terminate-translation))

;; Update the current translation status according to CONTROL-FLAG.
;; If CONTROL-FLAG is integer value, it is the number of keys in the
;; head quail-current-key which can be translated.  The remaining keys
;; are put back to unread-command-events to be handled again.
;; If CONTROL-FLAG is t, terminate the translation for the whole keys
;; in quail-current-key.
;; If CONTROL-FLAG is nil, proceed the translation with more keys.

(defun quail-update-translation (control-flag)

	(funcall func control-flag)
      (if (numberp control-flag)
	  (let ((len (length quail-current-key)))
	    (while (> len control-flag)
	      (setq len (1- len))
	      (setq unread-command-events
		    (cons (aref quail-current-key len)
			  unread-command-events)))
	    ;; Insert the translated sequence.
	    ;; It is a string containing multibyte characters.
	    ;; If enable-multibyte-characters, just insert it.
	    (if enable-multibyte-characters
		(insert (or quail-current-str

			      (substring quail-current-key 0 len))))
		(if (stringp char)
		    (setq char (sref char 0)))
		(if (= (length (split-char char)) 2)
		    (insert-char (logand char 255) 1)
		  (error "Three-byte characters require enabling multibyte characters")))))
	(insert (or quail-current-str quail-current-key)))))
  (quail-update-guidance)
  (if control-flag
      (quail-terminate-translation)))

  (unless (catch 'quail-tag
	    (quail-update-translation (quail-translate-key))
	    t)
    ;; If someone throws for `quail-tag' by value nil, we exit from
    ;; translation mode.
    (setq overriding-terminal-local-map nil)))

;; Return the actual definition part of Quail map MAP.
(defun quail-map-definition (map)
  (let ((def (car map)))
    (if (and (consp def) (not (vectorp (cdr def))))

	    ;; We are already at the tail.
	    (beep)
	  (setcar indices (1+ (car indices)))
	  (quail-update-current-translations)
	  (quail-update-translation nil)))
    (quail-execute-non-quail-command)))

(defun quail-prev-translation ()
  "Select previous translation in the current batch of candidates."
  (interactive)
  (if quail-current-translations

	    ;; We are already at the head.
	    (beep)
	  (setcar indices (1- (car indices)))
	  (quail-update-current-translations)
	  (quail-update-translation nil)))
    (quail-execute-non-quail-command)))

(defun quail-next-translation-block ()
  "Select from the next block of translations."
  (interactive)
  (if quail-current-translations

	    ;; We are already at the last block.
	    (beep)
	  (setcar indices (+ (nth 2 indices) offset))
	  (quail-update-current-translations)
	  (quail-update-translation nil)))
    (quail-execute-non-quail-command)))

(defun quail-prev-translation-block ()
  "Select the previous batch of 10 translation candidates."
  (interactive)
  (if quail-current-translations

	  (if (< (+ (nth 1 indices) offset) (nth 2 indices))
	      (progn
		(setcar indices (+ (nth 1 indices) offset))
		(quail-update-current-translations)))
	  (quail-update-translation nil)))
    (quail-execute-non-quail-command)))

(defun quail-abort-translation ()
  "Abort translation and delete the current Quail key sequence."
  (interactive)
  (quail-delete-region)

;; For conversion mode.

(defun quail-conversion-backward-char ()
  (interactive)
  (if (<= (point) (overlay-start quail-conv-overlay))
      (error "Beginning of conversion region"))
  (forward-char -1))

(defun quail-conversion-forward-char ()
  (interactive)
  (if (>= (point) (overlay-end quail-conv-overlay))
      (error "End of conversion region"))
  (forward-char 1))

(defun quail-conversion-beginning-of-region ()
  (interactive)
  (goto-char (overlay-start quail-conv-overlay)))

  (goto-char (overlay-end quail-conv-overlay)))

(defun quail-conversion-delete-char ()
  (interactive)
  (if (>= (point) (overlay-end quail-conv-overlay))
      (error "End of conversion region"))
  (delete-char 1)
  (when (= (overlay-start quail-conv-overlay)
	   (overlay-end quail-conv-overlay))
    (quail-delete-overlays)
    (setq overriding-terminal-local-map nil)))

(defun quail-conversion-backward-delete-char ()
  (interactive)
  (if (<= (point) (overlay-start quail-conv-overlay))
      (error "Beginning of conversion region"))
  (delete-char -1)
  (when (= (overlay-start quail-conv-overlay)
	   (overlay-end quail-conv-overlay))
    (quail-delete-overlays)
    (setq overriding-terminal-local-map nil)))

(defun quail-do-conversion (func &rest args)
  "Call FUNC to convert text in the current conversion region of Quail.
Remaining args are for FUNC."
  (delete-overlay quail-overlay)
  (apply func args))

(defun quail-no-conversion ()
  "Do no conversion of the current conversion region of Quail."
  (interactive)
  (quail-delete-overlays)
  (setq overriding-terminal-local-map nil)
  (run-hooks 'input-method-after-insert-chunk-hook))

;; Guidance, Completion, and Help buffer handlers.

;; Make a new one-line frame for Quail guidance buffer.

	  (if (and (not (eobp)) (get-text-property (point) 'mouse-face))
	      (setq end (point) beg (1+ (point))))
	  (if (and (not (bobp)) (get-text-property (1- (point)) 'mouse-face))
	      (setq end (1- (point)) beg (point)))
	  (if (null beg)
	      (error "No completion here"))
	  (setq beg (previous-single-property-change beg 'mouse-face))
	  (setq end (or (next-single-property-change end 'mouse-face)
			(point-max)))
	  (setq choice (buffer-substring beg end)))))
;    (let ((owindow (selected-window)))

    ;; active minibuffer.
    (if (and (string-match "\\` \\*Minibuf-[0-9]+\\*\\'" (buffer-name buffer))
	     (or (not (active-minibuffer-window))
		 (not (equal buffer
			     (window-buffer (active-minibuffer-window))))))
	(error "Minibuffer is not active for completion")
      ;; Insert the completion into the buffer where completion was requested.
      (set-buffer buffer)
;      (if base-size
;	  (delete-region (+ base-size (point-min)) (point))
;	(choose-completion-delete-max-match choice))

		  (quail-title)
		  "])\n---- Documentation ----\n"
		  (quail-docstring))
	  (newline)
	  (if (quail-show-layout) (quail-show-kbd-layout))
	  (quail-help-insert-keymap-description
	   quail-mode-map
	   "---- Key bindings (before starting translation) ----
key		binding
---		-------\n")
	  (quail-help-insert-keymap-description
	   (quail-translation-keymap)
	   "--- Key bindings (while translating) ---
key		binding
---		-------\n")

22765:7cf2c3800e8f

;; A main window showing Quail guidance buffer.
(defvar quail-guidance-win nil)
(make-variable-buffer-local 'quail-guidance-win)

(defvar quail-overlay nil
  "Overlay which covers the current translation region of Quail.")
(make-variable-buffer-local 'quail-overlay)

(defvar quail-conv-overlay nil
  "Overlay which covers the text to be converted in Quail mode.")
(make-variable-buffer-local 'quail-conv-overlay)

(defvar quail-current-key nil
  "Current key for translation in Quail mode.")
(make-variable-buffer-local 'quail-current-key)

(defvar quail-current-str nil
  "Currently selected translation of the current key.")
(make-variable-buffer-local 'quail-current-str)

(defvar quail-current-translations nil
  "Cons of indices and vector of possible translations of the current key.
Indices is a list of (CURRENT START END BLOCK BLOCKS), where
CURRENT is an index of the current translation,
START and END are indices of the start and end of the current block,
BLOCK is the current block index,
BLOCKS is a number of  blocks of translation.")
(make-variable-buffer-local 'quail-current-translations)

(defvar quail-current-data nil
  "Any Lisp object holding information of current translation status.
When a key sequence is mapped to TRANS and TRANS is a cons
of actual translation and some Lisp object to be refered
for translating the longer key sequence, this variable is set
to that Lisp object.")
(make-variable-buffer-local 'quail-current-data)

;; Quail package handlers.

(defvar quail-package-alist nil
  "List of Quail packages.

LEIM is available from the same ftp directory as Emacs."))
		(error "Can't use the Quail package `%s'" package-name))
	    (setq libraries (cdr libraries))))))
  (quail-select-package package-name)
  (setq current-input-method-title (quail-title))
  (quail-activate))

(defconst quail-translation-keymap
  (let ((map (make-keymap))
	(i ?\ ))
    (while (< i 127)
      (define-key map (char-to-string i) 'quail-self-insert-command)
      (setq i (1+ i)))
    (setq i 128)
    (while (< i 256)

    ;; any completion visible in the *Quail Completions* buffer.
    (define-key map [kp-enter] 'quail-select-current)
    (define-key map [mouse-2] 'quail-mouse-choose-completion)
    (define-key map [down-mouse-2] nil)
    (define-key map "\C-h" 'quail-translation-help)
    (define-key map [?\C- ] 'quail-select-current)
    (define-key map [tab] 'quail-completion)
    (define-key map [delete] 'quail-delete-last-char)
    (define-key map [backspace] 'quail-delete-last-char)
    (let ((meta-map (make-sparse-keymap)))
      (define-key map (char-to-string meta-prefix-char) meta-map)
      (define-key map [escape] meta-map))
    map)
  "Keymap used processing translation in complex Quail modes.
Only a few especially complex input methods use this map;
most use `quail-simple-translation-keymap' instead.
This map is activated while translation region is active.")

(defconst quail-simple-translation-keymap
  (let ((map (make-keymap))
	(i ?\ ))
    (while (< i 127)
      (define-key map (char-to-string i) 'quail-self-insert-command)
      (setq i (1+ i)))
    (define-key map "\177" 'quail-delete-last-char)
    (define-key map [delete] 'quail-delete-last-char)
    (define-key map [backspace] 'quail-delete-last-char)
    (let ((meta-map (make-sparse-keymap)))
      (define-key map (char-to-string meta-prefix-char) meta-map)
      (define-key map [escape] meta-map))
    map)
  "Keymap used while processing translation in simple Quail modes.
A few especially complex input methods use `quail--translation-keymap' instead.
This map is activated while translation region is active.")

(defconst quail-conversion-keymap
  (let ((map (make-keymap))
	(i ?\ ))
    (while (< i 127)
      (define-key map (char-to-string i) 'quail-self-insert-command)
      (setq i (1+ i)))
    (setq i 128)
    (while (< i 256)
      (define-key map (vector i) 'quail-self-insert-command)
      (setq i (1+ i)))
    (define-key map "\C-b" 'quail-conversion-backward-char)
    (define-key map "\C-f" 'quail-conversion-forward-char)
    (define-key map "\C-a" 'quail-conversion-beginning-of-region)
    (define-key map "\C-e" 'quail-conversion-end-of-region)
    (define-key map "\C-d" 'quail-conversion-delete-char)
    (define-key map "\C-h" 'quail-conversion-help)
    (define-key map "\177" 'quail-conversion-backward-delete-char)
    (define-key map [delete] 'quail-conversion-backward-delete-char)
    (define-key map [backspace] 'quail-conversion-backward-delete-char)
    map)
  "Keymap used for processing conversion in Quail mode.
This map is activated while convesion region is active but translation
region is not active.")

	  (if input-method-highlight-flag
	      (overlay-put quail-conv-overlay 'face 'underline))))))

;; Delete overlays used in Quail mode.
(defun quail-delete-overlays ()
  (if (and (overlayp quail-overlay) (overlay-start quail-overlay))
      (delete-overlay quail-overlay))
  (if (and (overlayp quail-conv-overlay) (overlay-start quail-conv-overlay))
      (delete-overlay quail-conv-overlay)))

;; Kill Quail guidance buffer.  Set in kill-buffer-hook.
(defun quail-kill-guidance-buf ()
  (if (buffer-live-p quail-guidance-buf)
      (kill-buffer quail-guidance-buf)))

(defun quail-inactivate ()
  "Inactivate Quail input method."
  (interactive)
  (quail-activate -1))

(defun quail-activate (&optional arg)
  "Activate Quail input method.
With arg, activate Quail input method if and only if arg is positive.

While this input method is active, the variable
`input-method-function' is bound to the function `quail-input-method'."
  (if (and arg
	  (< (prefix-numeric-value arg) 0))
      ;; Let's inactivate Quail input method.
      (unwind-protect
	  (progn
	    (quail-hide-guidance-buf)
	    (quail-delete-overlays)
	    (setq describe-current-input-method-function nil)
	    (run-hooks 'quail-inactivate-hook))
	(kill-local-variable 'input-method-function))
    ;; Let's active Quail input method.
    (if (null quail-current-package)
	;; Quail package is not yet selected.  Select one now.
	(let (name)
	  (if quail-package-alist
	      (setq name (car (car quail-package-alist)))
	    (error "No Quail package loaded"))
	  (quail-select-package name)))
    (setq inactivate-current-input-method-function 'quail-inactivate)
    (setq describe-current-input-method-function 'quail-help)
    (quail-delete-overlays)
    (quail-show-guidance-buf)
    ;; If we are in minibuffer, turn off the current input method
    ;; before exiting.
    (if (eq (selected-window) (minibuffer-window))
	(add-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer))
    (make-local-hook 'kill-buffer-hook)
    (add-hook 'kill-buffer-hook 'quail-kill-guidance-buf nil t)
    (run-hooks 'quail-activate-hook)
    (make-local-variable 'input-method-function)
    (setq input-method-function 'quail-input-method)))

(defun quail-exit-from-minibuffer ()
  (inactivate-input-method)
  (if (<= (minibuffer-depth) 1)
      (remove-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer)))

;; Keyboard layout translation handlers.

;; Some Quail packages provide localized keyboard simulation which
;; requires a particular keyboard layout.  In this case, what we need

	      (progn
		(setcdr map (funcall (cdr map) key len))))
	  ))
    map))

(put 'quail-error 'error-conditions '(quail-error error))
(defun quail-error (&rest args)
  (signal 'quail-error (apply 'format args)))

(defvar quail-translating nil)
(defvar quail-converting nil)

(defun quail-input-method (key)
  (if (or buffer-read-only
	  (and (or overriding-terminal-local-map
		   overriding-local-map)
	       (>= key ?0) (<= key ?9)))
      (list key)
    (quail-setup-overlays (quail-conversion-keymap))
    (let ((modified-p (buffer-modified-p)))
      (unwind-protect
	  (if (quail-conversion-keymap)
	      (quail-start-conversion key)
	    (quail-start-translation key))
	(set-buffer-modified-p modified-p)
	(quail-delete-overlays)))))

(defun quail-overlay-region-events (overlay)
  (let ((start (overlay-start overlay))
	(end (overlay-end overlay)))
    (if (< start end)
	(prog1
	    (string-to-list (buffer-substring start end))
	  (delete-region start end)))))

(defun quail-start-translation (key)
  "Start translation of the typed character KEY by the current Quail package."
  ;; Check the possibility of translating KEY.
  (if (and (integerp key)
	   (assq (if (quail-kbd-translate) (quail-keyboard-translate key) key)
		 (cdr (quail-map))))
      ;; Ok, we can start translation.
      (let* ((translation-keymap (quail-translation-keymap))
	     (overriding-terminal-local-map translation-keymap)
	     (generated-events nil)
	     (input-method-function nil))
	(setq quail-current-key ""
	      quail-current-str nil
	      quail-translating t
	      unread-command-events (cons key unread-command-events))
	(while quail-translating
	  (let* ((echo-keystrokes 0)
		 (keyseq (read-key-sequence nil))
		 (cmd (lookup-key translation-keymap keyseq t)))
	    (if (commandp cmd)
		(progn
		  (setq last-command-event (aref keyseq 0))
		  (condition-case err
		      (call-interactively cmd)
		    (quail-error (message "%s" (cdr err)) (beep))))
	      ;; KEYSEQ is not defined in the translation keymap.
	      ;; Let's return the event(s) to the caller.
	      (setq generated-events (string-to-list keyseq)
		    quail-translating nil))))
	(setq generated-events
	      (append (quail-overlay-region-events quail-overlay)
		      generated-events))
	generated-events)

    ;; Since KEY doesn't start any translation, just return it.
    (list key)))

(defun quail-start-conversion (key)
  "Start conversion of the typed character KEY by the current Quail package."
  ;; Check the possibility of translating KEY.
  (if (and (integerp key)
	   (assq (if (quail-kbd-translate) (quail-keyboard-translate key) key)
		 (cdr (quail-map))))
      ;; Ok, we can start translation and conversion.
      (let* ((conversion-keymap (quail-conversion-keymap))
	     (overriding-terminal-local-map conversion-keymap)
	     (generated-events nil)
	     (input-method-function nil))
	(setq quail-current-key ""
	      quail-current-str nil
	      quail-converting t
	      quail-translating t
	      unread-command-events (cons key unread-command-events))
	(while quail-converting
	  (or quail-translating
	      (progn
		(setq quail-current-key ""
		      quail-current-str nil
		      quail-translating t)
		(quail-setup-overlays nil)))
	  (let* ((echo-keystrokes 0)
		 (keyseq (read-key-sequence nil))
		 (cmd (lookup-key conversion-keymap keyseq t)))
	    (if (commandp cmd)
		(progn
		  (setq last-command-event (aref keyseq 0))
		  (condition-case err
		      (call-interactively cmd)
		    (quail-error (message "%s" (cdr err)) (beep))))
	      ;; KEYSEQ is not defined in the conversion keymap.
	      ;; Let's return the event(s) to the caller.
	      (setq generated-events (string-to-list keyseq)
		    quail-converting nil))))
	(setq generated-events
	      (append (quail-overlay-region-events quail-conv-overlay)
		      generated-events))
	generated-events)

    ;; Since KEY doesn't start any translation, just return it.
    (list key)))

(defsubst quail-delete-region ()
  "Delete the text in the current translation region of Quail."
  (if (overlay-start quail-overlay)
      (delete-region (overlay-start quail-overlay)
		     (overlay-end quail-overlay))))

(defun quail-terminate-translation ()
  "Terminate the translation of the current key."
  (setq quail-translating nil)
  (if (buffer-live-p quail-guidance-buf)
      (save-excursion
	(set-buffer quail-guidance-buf)
	(erase-buffer))))

(defun quail-select-current ()
  "Select the current text shown in Quail translation region."
  (interactive)
  (quail-terminate-translation))

;; Update the current translation status according to CONTROL-FLAG.
;; If CONTROL-FLAG is integer value, it is the number of keys in the
;; head quail-current-key which can be translated.  The remaining keys
;; are put back to unread-input-method-events to be handled again.
;; If CONTROL-FLAG is t, terminate the translation for the whole keys
;; in quail-current-key.
;; If CONTROL-FLAG is nil, proceed the translation with more keys.

(defun quail-update-translation (control-flag)

	(funcall func control-flag)
      (if (numberp control-flag)
	  (let ((len (length quail-current-key)))
	    (while (> len control-flag)
	      (setq len (1- len))
	      (setq unread-input-method-events
		    (cons (aref quail-current-key len)
			  unread-input-method-events)))
	    ;; Insert the translated sequence.
	    ;; It is a string containing multibyte characters.
	    ;; If enable-multibyte-characters, just insert it.
	    (if enable-multibyte-characters
		(insert (or quail-current-str

			      (substring quail-current-key 0 len))))
		(if (stringp char)
		    (setq char (sref char 0)))
		(if (= (length (split-char char)) 2)
		    (insert-char (logand char 255) 1)
		  (quail-error "Three-byte characters require enabling multibyte characters")))))
	(insert (or quail-current-str quail-current-key)))))
  (quail-update-guidance)
  (if control-flag
      (quail-terminate-translation)))

  (unless (catch 'quail-tag
	    (quail-update-translation (quail-translate-key))
	    t)
    ;; If someone throws for `quail-tag' by value nil, we exit from
    ;; translation mode.
    (setq quail-translating nil)))

;; Return the actual definition part of Quail map MAP.
(defun quail-map-definition (map)
  (let ((def (car map)))
    (if (and (consp def) (not (vectorp (cdr def))))

	    ;; We are already at the tail.
	    (beep)
	  (setcar indices (1+ (car indices)))
	  (quail-update-current-translations)
	  (quail-update-translation nil)))
    (setq unread-command-events
	  (cons last-command-event unread-command-events))
    (quail-terminate-translation)))

(defun quail-prev-translation ()
  "Select previous translation in the current batch of candidates."
  (interactive)
  (if quail-current-translations

	    ;; We are already at the head.
	    (beep)
	  (setcar indices (1- (car indices)))
	  (quail-update-current-translations)
	  (quail-update-translation nil)))
    (setq unread-command-events
	  (cons last-command-event unread-command-events))
    (quail-terminate-translation)))

(defun quail-next-translation-block ()
  "Select from the next block of translations."
  (interactive)
  (if quail-current-translations

	    ;; We are already at the last block.
	    (beep)
	  (setcar indices (+ (nth 2 indices) offset))
	  (quail-update-current-translations)
	  (quail-update-translation nil)))
    (setq unread-command-events
	  (append (string-to-list unread-command-events)))
    (quail-terminate-translation)))

(defun quail-prev-translation-block ()
  "Select the previous batch of 10 translation candidates."
  (interactive)
  (if quail-current-translations

	  (if (< (+ (nth 1 indices) offset) (nth 2 indices))
	      (progn
		(setcar indices (+ (nth 1 indices) offset))
		(quail-update-current-translations)))
	  (quail-update-translation nil)))
    (setq unread-command-events
	  (cons last-command-event unread-command-events))
    (quail-terminate-translation)))

(defun quail-abort-translation ()
  "Abort translation and delete the current Quail key sequence."
  (interactive)
  (quail-delete-region)

;; For conversion mode.

(defun quail-conversion-backward-char ()
  (interactive)
  (if (<= (point) (overlay-start quail-conv-overlay))
      (quail-error "Beginning of conversion region"))
  (setq quail-translating nil)
  (forward-char -1))

(defun quail-conversion-forward-char ()
  (interactive)
  (if (>= (point) (overlay-end quail-conv-overlay))
      (quail-error "End of conversion region"))
  (setq quail-translating nil)
  (forward-char 1))

(defun quail-conversion-beginning-of-region ()
  (interactive)
  (goto-char (overlay-start quail-conv-overlay)))

  (goto-char (overlay-end quail-conv-overlay)))

(defun quail-conversion-delete-char ()
  (interactive)
  (if (>= (point) (overlay-end quail-conv-overlay))
      (quail-error "End of conversion region"))
  (delete-char 1)
  (if (= (overlay-start quail-conv-overlay)
	 (overlay-end quail-conv-overlay))
      (setq quail-converting nil)))

(defun quail-conversion-backward-delete-char ()
  (interactive)
  (if (<= (point) (overlay-start quail-conv-overlay))
      (quail-error "Beginning of conversion region"))
  (delete-char -1)
  (if (= (overlay-start quail-conv-overlay)
	 (overlay-end quail-conv-overlay))
      (setq quail-converting nil)))

(defun quail-do-conversion (func &rest args)
  "Call FUNC to convert text in the current conversion region of Quail.
Remaining args are for FUNC."
  (delete-overlay quail-overlay)
  (apply func args))

(defun quail-no-conversion ()
  "Do no conversion of the current conversion region of Quail."
  (interactive)
  (setq quail-converting nil)
  (run-hooks 'input-method-after-insert-chunk-hook))

;; Guidance, Completion, and Help buffer handlers.

;; Make a new one-line frame for Quail guidance buffer.

	  (if (and (not (eobp)) (get-text-property (point) 'mouse-face))
	      (setq end (point) beg (1+ (point))))
	  (if (and (not (bobp)) (get-text-property (1- (point)) 'mouse-face))
	      (setq end (1- (point)) beg (point)))
	  (if (null beg)
	      (quail-error "No completion here"))
	  (setq beg (previous-single-property-change beg 'mouse-face))
	  (setq end (or (next-single-property-change end 'mouse-face)
			(point-max)))
	  (setq choice (buffer-substring beg end)))))
;    (let ((owindow (selected-window)))

    ;; active minibuffer.
    (if (and (string-match "\\` \\*Minibuf-[0-9]+\\*\\'" (buffer-name buffer))
	     (or (not (active-minibuffer-window))
		 (not (equal buffer
			     (window-buffer (active-minibuffer-window))))))
	(quail-error "Minibuffer is not active for completion")
      ;; Insert the completion into the buffer where completion was requested.
      (set-buffer buffer)
;      (if base-size
;	  (delete-region (+ base-size (point-min)) (point))
;	(choose-completion-delete-max-match choice))

		  (quail-title)
		  "])\n---- Documentation ----\n"
		  (quail-docstring))
	  (newline)
	  (if (quail-show-layout) (quail-show-kbd-layout))
	  (quail-help-insert-keymap-description
	   (quail-translation-keymap)
	   "--- Key bindings (while translating) ---
key		binding
---		-------\n")