|
165
|
1 ;;; quail.el --- Provides simple input method for multilingual text
|
|
155
|
2
|
|
|
3 ;; Copyright (C) 1995 Free Software Foundation, Inc.
|
|
|
4 ;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
|
|
|
5 ;; Copyright (C) 1997 MORIOKA Tomohiko
|
|
|
6
|
|
|
7 ;; Author: Kenichi HANDA <handa@etl.go.jp>
|
|
|
8 ;; Naoto TAKAHASHI <ntakahas@etl.go.jp>
|
|
|
9 ;; modified by MORIOKA Tomohiko <morioka@jaist.ac.jp> for XEmacs
|
|
|
10 ;; Keywords: mule, multilingual, input method
|
|
|
11
|
|
|
12 ;; This file is part of GNU Emacs.
|
|
|
13
|
|
|
14 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
15 ;; it under the terms of the GNU General Public License as published by
|
|
|
16 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
17 ;; any later version.
|
|
|
18
|
|
|
19 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
22 ;; GNU General Public License for more details.
|
|
|
23
|
|
|
24 ;; You should have received a copy of the GNU General Public License
|
|
|
25 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
26 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
27 ;; Boston, MA 02111-1307, USA.
|
|
|
28
|
|
|
29 ;;; Commentary:
|
|
|
30
|
|
|
31 ;; In Quail minor mode, you can input multilingual text easily. By
|
|
|
32 ;; defining a translation table (named Quail map) which maps ASCII key
|
|
|
33 ;; string to multilingual character or string, you can input any text
|
|
|
34 ;; from ASCII keyboard.
|
|
|
35 ;;
|
|
|
36 ;; We use words "translation" and "conversion" differently. The
|
|
|
37 ;; former is done by Quail package itself, the latter is the further
|
|
|
38 ;; process of converting a translated text to some more desirable
|
|
|
39 ;; text. For instance, Quail package for Japanese (`quail-jp')
|
|
|
40 ;; translates Roman text (transliteration of Japanese in Latin
|
|
|
41 ;; alphabets) to Hiragana text, which is then converted to
|
|
|
42 ;; Kanji-and-Kana mixed text or Katakana text by commands specified in
|
|
|
43 ;; CONVERSION-KEYS argument of the Quail package.
|
|
|
44
|
|
|
45 ;;; Code:
|
|
|
46
|
|
|
47 (eval-when-compile
|
|
|
48 (if (string-match "XEmacs" emacs-version)
|
|
|
49 (require 'overlay)
|
|
|
50 ))
|
|
|
51
|
|
|
52 (cond
|
|
|
53 ((featurep 'xemacs)
|
|
|
54 (require 'overlay)
|
|
|
55 )
|
|
|
56 (t
|
|
|
57 (require 'faces)
|
|
|
58 ))
|
|
|
59
|
|
|
60 ;; Buffer local variables
|
|
|
61
|
|
|
62 (defvar quail-current-package nil
|
|
|
63 "The current Quail package to input multilingual text in Quail minor mode.
|
|
|
64 See the documentation of `quail-package-alist' for the format.")
|
|
|
65 (make-variable-buffer-local 'quail-current-package)
|
|
|
66 (put 'quail-current-package 'permanent-local t)
|
|
|
67
|
|
|
68 ;; Quail uses the following two buffers to assist users.
|
|
|
69 ;; A buffer to show available key sequence or translation list.
|
|
|
70 (defvar quail-guidance-buf nil)
|
|
|
71 ;; A buffer to show completion list of the current key sequence.
|
|
|
72 (defvar quail-completion-buf nil)
|
|
|
73
|
|
|
74 (defvar quail-mode nil
|
|
|
75 "Non-nil if in Quail minor mode.")
|
|
|
76 (make-variable-buffer-local 'quail-mode)
|
|
|
77 (put 'quail-mode 'permanent-local t)
|
|
|
78
|
|
|
79 (defvar quail-overlay nil
|
|
|
80 "Overlay which covers the current translation region of Quail.")
|
|
|
81 (make-variable-buffer-local 'quail-overlay)
|
|
|
82
|
|
|
83 (defvar quail-conv-overlay nil
|
|
|
84 "Overlay which covers the text to be converted in Quail mode.")
|
|
|
85 (make-variable-buffer-local 'quail-conv-overlay)
|
|
|
86
|
|
|
87 (defvar quail-current-key nil
|
|
|
88 "Current key for translation in Quail mode.")
|
|
|
89
|
|
|
90 (defvar quail-current-str nil
|
|
|
91 "Currently selected translation of the current key.")
|
|
|
92
|
|
|
93 (defvar quail-current-translations nil
|
|
|
94 "Cons of indices and vector of possible translations of the current key.")
|
|
|
95
|
|
165
|
96 (defvar quail-current-data nil
|
|
|
97 "Any Lisp object holding information of current translation status.
|
|
|
98 When a key sequence is mapped to TRANS and TRANS is a cons
|
|
|
99 of actual translation and some Lisp object to be refered
|
|
|
100 for translating the longer key sequence, this variable is set
|
|
|
101 to that Lisp object.")
|
|
|
102
|
|
155
|
103 ;; A flag to control conversion region. Normally nil, but if set to
|
|
|
104 ;; t, it means we must start the new conversion region if new key to
|
|
|
105 ;; be translated is input.
|
|
|
106 (defvar quail-reset-conversion-region nil)
|
|
|
107
|
|
|
108 ;; Quail package handlers.
|
|
|
109
|
|
|
110 (defvar quail-package-alist nil
|
|
|
111 "List of Quail packages.
|
|
|
112 A Quail package is a list of these elements:
|
|
|
113 NAME, TITLE, QUAIL-MAP, GUIDANCE, DOCSTRING, TRANSLATION-KEYS,
|
|
|
114 FORGET-LAST-SELECTION, DETERMINISTIC, KBD-TRANSLATE, SHOW-LAYOUT,
|
|
|
115 DECODE-MAP, MAXIMUM-SHORTEST, OVERLAY-PLIST, UPDATE-TRANSLATION-FUNCTION,
|
|
|
116 CONVERSION-KEYS.
|
|
|
117
|
|
|
118 QUAIL-MAP is a data structure to map key strings to translations. For
|
|
|
119 the format, see the documentation of `quail-map-p'.
|
|
|
120
|
|
|
121 DECODE-MAP is an alist of translations and corresponding keys.
|
|
|
122
|
|
|
123 See the documentation of `quail-define-package' for the other elements.")
|
|
|
124
|
|
|
125 ;; Return various slots in the current quail-package.
|
|
|
126
|
|
|
127 (defsubst quail-name ()
|
|
|
128 "Return the name of the current Quail package."
|
|
|
129 (nth 0 quail-current-package))
|
|
|
130 (defsubst quail-title ()
|
|
|
131 "Return the title of the current Quail package."
|
|
|
132 (nth 1 quail-current-package))
|
|
|
133 (defsubst quail-map ()
|
|
|
134 "Return the translation map of the current Quail package."
|
|
|
135 (nth 2 quail-current-package))
|
|
|
136 (defsubst quail-guidance ()
|
|
|
137 "Return an object used for `guidance' feature of the current Quail package.
|
|
|
138 See also the documentation of `quail-define-package'."
|
|
|
139 (nth 3 quail-current-package))
|
|
|
140 (defsubst quail-docstring ()
|
|
|
141 "Return the documentation string of the current Quail package."
|
|
|
142 (nth 4 quail-current-package))
|
|
|
143 (defsubst quail-translation-keymap ()
|
|
|
144 "Return translation keymap in the current Quail package.
|
|
|
145 Translation keymap is a keymap used while translation region is active."
|
|
|
146 (nth 5 quail-current-package))
|
|
|
147 (defsubst quail-forget-last-selection ()
|
|
|
148 "Return `forget-last-selection' flag of the current Quail package.
|
|
|
149 See also the documentation of `quail-define-package'."
|
|
|
150 (nth 6 quail-current-package))
|
|
|
151 (defsubst quail-deterministic ()
|
|
|
152 "Return `deterministic' flag of the current Quail package.
|
|
|
153 See also the documentation of `quail-define-package'."
|
|
|
154 (nth 7 quail-current-package))
|
|
|
155 (defsubst quail-kbd-translate ()
|
|
|
156 "Return `kbd-translate' flag of the current Quail package.
|
|
|
157 See also the documentation of `quail-define-package'."
|
|
|
158 (nth 8 quail-current-package))
|
|
|
159 (defsubst quail-show-layout ()
|
|
|
160 "Return `show-layout' flag of the current Quail package.
|
|
|
161 See also the documentation of `quail-define-package'."
|
|
|
162 (nth 9 quail-current-package))
|
|
|
163 (defsubst quail-decode-map ()
|
|
|
164 "Return decode map of the current Quail package.
|
|
|
165 It is an alist of translations and corresponding keys."
|
|
|
166 (nth 10 quail-current-package))
|
|
|
167 (defsubst quail-maximum-shortest ()
|
|
|
168 "Return `maximum-shortest' flag of the current Quail package.
|
|
|
169 See also the documentation of `quail-define-package'."
|
|
|
170 (nth 11 quail-current-package))
|
|
|
171 (defsubst quail-overlay-plist ()
|
|
|
172 "Return property list of an overly used in the current Quail package."
|
|
|
173 (nth 12 quail-current-package))
|
|
|
174 (defsubst quail-update-translation-function ()
|
|
|
175 "Return a function for updating translation in the current Quail package."
|
|
|
176 (nth 13 quail-current-package))
|
|
|
177 (defsubst quail-conversion-keymap ()
|
|
|
178 "Return conversion keymap in the current Quail package.
|
|
|
179 Conversion keymap is a keymap used while conversion region is active
|
|
|
180 but translation region is not active."
|
|
|
181 (nth 14 quail-current-package))
|
|
|
182
|
|
|
183 (defsubst quail-package (name)
|
|
|
184 "Return Quail package named NAME."
|
|
|
185 (assoc name quail-package-alist))
|
|
|
186
|
|
|
187 (defun quail-add-package (package)
|
|
|
188 "Add Quail package PACKAGE to `quail-package-alist'."
|
|
|
189 (let ((pac (quail-package (car package))))
|
|
|
190 (if pac
|
|
|
191 (setcdr pac (cdr package))
|
|
|
192 (setq quail-package-alist (cons package quail-package-alist)))))
|
|
|
193
|
|
|
194 (defun quail-select-package (name)
|
|
|
195 "Select Quail package named NAME as the current Quail package."
|
|
|
196 (let ((package (quail-package name)))
|
|
|
197 (if (null package)
|
|
|
198 (error "No Quail package `%s'" name))
|
|
|
199 (setq quail-current-package package)
|
|
|
200 (setq-default quail-current-package package)
|
|
|
201 name))
|
|
|
202
|
|
|
203 ;;;###autoload
|
|
|
204 (defun quail-use-package (package-name &rest libraries)
|
|
|
205 "Start using Quail package PACKAGE-NAME.
|
|
|
206 The remaining arguments are libraries to be loaded before using the package."
|
|
|
207 (while libraries
|
|
|
208 (if (not (load (car libraries) t))
|
|
|
209 (progn
|
|
|
210 (with-output-to-temp-buffer "*Help*"
|
|
|
211 (princ "Quail package \"")
|
|
|
212 (princ package-name)
|
|
|
213 (princ "\" can't be activated\n because library \"")
|
|
|
214 (princ (car libraries))
|
|
|
215 (princ "\" is not in `load-path'.
|
|
|
216
|
|
|
217 The most common case is that you have not yet installed appropriate
|
|
|
218 libraries in LEIM (Libraries of Emacs Input Method) which is
|
|
|
219 distributed separately from Emacs.
|
|
|
220
|
|
|
221 Installation of LEIM for Quail is very simple, just copy Quail
|
|
|
222 packages (byte-compiled Emacs Lisp files) to somewhere in your
|
|
|
223 `load-path'.
|
|
|
224
|
|
|
225 LEIM is available from the same ftp directory as Emacs."))
|
|
|
226 (error ""))
|
|
|
227 (setq libraries (cdr libraries))))
|
|
|
228 (quail-select-package package-name)
|
|
|
229 (setq current-input-method-title (quail-title))
|
|
|
230 (quail-mode 1))
|
|
|
231
|
|
|
232 (defun quail-inactivate ()
|
|
|
233 "Turn off Quail input method."
|
|
|
234 (interactive)
|
|
|
235 (throw 'quail-tag t))
|
|
|
236
|
|
|
237 (or (assq 'quail-mode minor-mode-alist)
|
|
|
238 (setq minor-mode-alist
|
|
|
239 (cons '(quail-mode " Quail") minor-mode-alist)))
|
|
|
240
|
|
|
241 (defvar quail-mode-map
|
|
|
242 (let ((map (make-keymap))
|
|
|
243 (i ? ))
|
|
|
244 (while (< i 127)
|
|
|
245 (define-key map (char-to-string i) 'quail-start-translation)
|
|
|
246 (setq i (1+ i)))
|
|
|
247 map)
|
|
|
248 "Keymap for Quail mode.")
|
|
|
249
|
|
|
250 (or (assq 'quail-mode minor-mode-map-alist)
|
|
|
251 (setq minor-mode-map-alist
|
|
|
252 (cons (cons 'quail-mode quail-mode-map) minor-mode-map-alist)))
|
|
|
253
|
|
|
254 ;; Since some Emacs Lisp programs (e.g. viper.el) make
|
|
|
255 ;; minor-mode-map-alist buffer-local, we must be sure to register
|
|
|
256 ;; quail-mode-map in default-value of minor-mode-map-alist.
|
|
|
257 (if (local-variable-p 'minor-mode-map-alist nil)
|
|
|
258 (let ((map (default-value 'minor-mode-map-alist)))
|
|
|
259 (or (assq 'quail-mode map)
|
|
169
|
260 ;; (set-default 'minor-mode-map-alist (cons 'quail-mode map)))))
|
|
|
261 (set-default 'minor-mode-map-alist
|
|
|
262 (cons (cons 'quail-mode quail-mode-map) map)))))
|
|
155
|
263
|
|
|
264 (defvar quail-translation-keymap
|
|
|
265 (let ((map (make-keymap))
|
|
|
266 (i 0))
|
|
|
267 (while (< i ?\ )
|
|
|
268 (define-key map (char-to-string i) 'quail-execute-non-quail-command)
|
|
|
269 (setq i (1+ i)))
|
|
|
270 (while (< i 127)
|
|
|
271 (define-key map (char-to-string i) 'quail-self-insert-command)
|
|
|
272 (setq i (1+ i)))
|
|
|
273 (define-key map "\177" 'quail-delete-last-char)
|
|
|
274 (define-key map "\C-\\" 'quail-inactivate)
|
|
|
275 (define-key map "\C-f" 'quail-next-translation)
|
|
|
276 (define-key map "\C-b" 'quail-prev-translation)
|
|
|
277 (define-key map "\C-n" 'quail-next-translation-block)
|
|
|
278 (define-key map "\C-p" 'quail-prev-translation-block)
|
|
|
279 (define-key map "\C-i" 'quail-completion)
|
|
|
280 (define-key map "\C-@" 'quail-select-current)
|
|
|
281 (define-key map "\C-c" 'quail-abort-translation)
|
|
|
282 (define-key map "\C-h" 'quail-translation-help)
|
|
|
283 ;; 1997/5/26 by MORIOKA Tomohiko
|
|
|
284 ;; modified for XEmacs
|
|
|
285 ;;(define-key map "\e" '(keymap (t . quail-execute-non-quail-command)))
|
|
|
286 (let ((emap (make-sparse-keymap)))
|
|
|
287 (set-keymap-default-binding emap 'quail-execute-non-quail-command)
|
|
|
288 (define-key map "\e" emap)
|
|
|
289 )
|
|
|
290 (define-key map [tab] 'quail-completion)
|
|
|
291 (define-key map [delete] 'quail-delete-last-char)
|
|
|
292 (define-key map [backspace] 'quail-delete-last-char)
|
|
|
293 ;; At last, define default key binding.
|
|
|
294 (set-keymap-default-binding map 'quail-execute-non-quail-command)
|
|
|
295 map)
|
|
|
296 "Keymap used processing translation in Quail mode.
|
|
|
297 This map is activated while translation region is active.")
|
|
|
298
|
|
|
299 (defvar quail-conversion-keymap
|
|
|
300 (let ((map (make-keymap))
|
|
|
301 (i 0))
|
|
|
302 (while (< i ?\ )
|
|
|
303 (define-key map (char-to-string i) 'quail-execute-non-quail-command)
|
|
|
304 (setq i (1+ i)))
|
|
|
305 (while (< i 127)
|
|
|
306 (define-key map (char-to-string i)
|
|
|
307 'quail-start-translation-in-conversion-mode)
|
|
|
308 (setq i (1+ i)))
|
|
|
309 (define-key map "\C-b" 'quail-conversion-backward-char)
|
|
|
310 (define-key map "\C-f" 'quail-conversion-forward-char)
|
|
|
311 (define-key map "\C-a" 'quail-conversion-beginning-of-region)
|
|
|
312 (define-key map "\C-e" 'quail-conversion-end-of-region)
|
|
|
313 (define-key map "\C-d" 'quail-conversion-delete-char)
|
|
|
314 (define-key map "\C-h" 'quail-conversion-help)
|
|
|
315 (define-key map "\C-\\" 'quail-inactivate)
|
|
|
316 ;; 1997/5/26 by MORIOKA Tomohiko
|
|
|
317 ;; modified for XEmacs
|
|
|
318 ;;(define-key map "\e" '(keymap (t . quail-execute-non-quail-command)))
|
|
|
319 (let ((emap (make-sparse-keymap)))
|
|
|
320 (set-keymap-default-binding emap 'quail-execute-non-quail-command)
|
|
|
321 (define-key map "\e" emap)
|
|
|
322 )
|
|
|
323 (define-key map "\177" 'quail-conversion-backward-delete-char)
|
|
|
324 (define-key map [delete] 'quail-conversion-backward-delete-char)
|
|
|
325 (define-key map [backspace] 'quail-conversion-backward-delete-char)
|
|
|
326 ;; At last, define default key binding.
|
|
|
327 (set-keymap-default-binding map 'quail-execute-non-quail-command)
|
|
|
328 map)
|
|
|
329 "Keymap used for processing conversion in Quail mode.
|
|
|
330 This map is activated while convesion region is active but translation
|
|
|
331 region is not active.")
|
|
|
332
|
|
|
333 (defun quail-define-package (name language title
|
|
|
334 &optional guidance docstring translation-keys
|
|
|
335 forget-last-selection deterministic
|
|
|
336 kbd-translate show-layout create-decode-map
|
|
|
337 maximum-shortest overlay-plist
|
|
|
338 update-translation-function
|
|
|
339 conversion-keys)
|
|
|
340 "Define NAME as a new Quail package for input LANGUAGE.
|
|
|
341 TITLE is a string to be displayed at mode-line to indicate this package.
|
|
|
342 Optional arguments are GUIDANCE, DOCSTRING, TRANLSATION-KEYS,
|
|
|
343 FORGET-LAST-SELECTION, DETERMINISTIC, KBD-TRANSLATE, SHOW-LAYOUT,
|
|
|
344 CREATE-DECODE-MAP, MAXIMUM-SHORTEST, OVERLAY-PLIST,
|
|
|
345 UPDATE-TRANSLATION-FUNCTION, and CONVERSION-KEYS.
|
|
|
346
|
|
|
347 GUIDANCE specifies how a guidance string is shown in echo area.
|
|
|
348 If it is t, list of all possible translations for the current key is shown
|
|
|
349 with the currently selected translation being highlighted.
|
|
|
350 If it is an alist, the element has the form (CHAR . STRING). Each character
|
|
|
351 in the current key is searched in the list and the corresponding string is
|
|
|
352 shown.
|
|
|
353 If it is nil, the current key is shown.
|
|
|
354
|
|
|
355 DOCSTRING is the documentation string of this package.
|
|
|
356
|
|
|
357 TRANSLATION-KEYS specifies additional key bindings used while translation
|
|
|
358 region is active. It is an alist of single key character vs. corresponding
|
|
|
359 command to be called.
|
|
|
360
|
|
|
361 FORGET-LAST-SELECTION non-nil means a selected translation is not kept
|
|
|
362 for the future to translate the same key. If this flag is nil, a
|
|
|
363 translation selected for a key is remembered so that it can be the
|
|
|
364 first candidate when the same key is entered later.
|
|
|
365
|
|
|
366 DETERMINISTIC non-nil means the first candidate of translation is
|
|
|
367 selected automatically without allowing users to select another
|
|
|
368 translation for a key. In this case, unselected translations are of
|
|
|
369 no use for an interactive use of Quail but can be used by some other
|
|
|
370 programs. If this flag is non-nil, FORGET-LAST-SELECTION is also set
|
|
|
371 to t.
|
|
|
372
|
|
|
373 KBD-TRANSLATE non-nil means input characters are translated from a
|
|
|
374 user's keyboard layout to the standard keyboard layout. See the
|
|
|
375 documentation of `quail-keyboard-layout' and
|
|
|
376 `quail-keyboard-layout-standard' for more detail.
|
|
|
377
|
|
|
378 SHOW-LAYOUT non-nil means the `quail-help' command should show
|
|
|
379 the user's keyboard layout visually with translated characters.
|
|
|
380 If KBD-TRANSLATE is set, it is desirable to set also this flag unless
|
|
|
381 this package defines no translations for single character keys.
|
|
|
382
|
|
|
383 CREATE-DECODE-MAP non-nil means decode map is also created. A decode
|
|
|
384 map is an alist of translations and corresponding original keys.
|
|
|
385 Although this map is not used by Quail itself, it can be used by some
|
|
|
386 other programs. For instance, Vietnamese supporting needs this map to
|
|
|
387 convert Vietnamese text to VIQR format which uses only ASCII
|
|
|
388 characters to represent Vietnamese characters.
|
|
|
389
|
|
|
390 MAXIMUM-SHORTEST non-nil means break key sequence to get maximum
|
|
|
391 length of the shortest sequence. When we don't have a translation of
|
|
|
392 key \"..ABCD\" but have translations of \"..AB\" and \"CD..\", break
|
|
|
393 the key at \"..AB\" and start translation of \"CD..\". Hangul
|
|
|
394 packages, for instance, use this facility. If this flag is nil, we
|
|
|
395 break the key just at \"..ABC\" and start translation of \"D..\".
|
|
|
396
|
|
|
397 OVERLAY-PLIST if non-nil is a property list put on an overlay which
|
|
|
398 covers Quail translation region.
|
|
|
399
|
|
|
400 UPDATE-TRANSLATION-FUNCTION if non-nil is a function to call to update
|
|
|
401 the current translation region accoding to a new translation data. By
|
|
|
402 default, a tranlated text or a user's key sequence (if no transltion
|
|
|
403 for it) is inserted.
|
|
|
404
|
|
|
405 CONVERSION-KEYS specifies additional key bindings used while
|
|
|
406 conversion region is active. It is an alist of single key character
|
|
|
407 vs. corresponding command to be called."
|
|
|
408 (let (translation-keymap conversion-keymap)
|
|
|
409 (if deterministic (setq forget-last-selection t))
|
|
|
410 (if translation-keys
|
|
|
411 (progn
|
|
|
412 (setq translation-keymap (copy-keymap quail-translation-keymap))
|
|
|
413 (while translation-keys
|
|
|
414 (define-key translation-keymap
|
|
|
415 (car (car translation-keys)) (cdr (car translation-keys)))
|
|
|
416 (setq translation-keys (cdr translation-keys))))
|
|
|
417 (setq translation-keymap quail-translation-keymap))
|
|
|
418 (if conversion-keys
|
|
|
419 (progn
|
|
|
420 (setq conversion-keymap (copy-keymap quail-conversion-keymap))
|
|
|
421 (while conversion-keys
|
|
|
422 (define-key conversion-keymap
|
|
|
423 (car (car conversion-keys)) (cdr (car conversion-keys)))
|
|
|
424 (setq conversion-keys (cdr conversion-keys)))))
|
|
|
425 (quail-add-package
|
|
|
426 (list name title (list nil) guidance (or docstring "")
|
|
|
427 translation-keymap
|
|
|
428 forget-last-selection deterministic kbd-translate show-layout
|
|
|
429 (if create-decode-map (list 'decode-map) nil)
|
|
|
430 maximum-shortest overlay-plist update-translation-function
|
|
|
431 conversion-keymap)))
|
|
|
432 (register-input-method language (list name 'quail-use-package))
|
|
|
433 (quail-select-package name))
|
|
|
434
|
|
|
435 ;; Quail minor mode handlers.
|
|
|
436
|
|
|
437 ;; Setup overlays used in Quail mode.
|
|
|
438 (defun quail-setup-overlays ()
|
|
|
439 (let ((pos (point)))
|
|
|
440 (if (overlayp quail-overlay)
|
|
|
441 (move-overlay quail-overlay pos pos)
|
|
|
442 (setq quail-overlay (make-overlay pos pos nil nil t))
|
|
|
443 (overlay-put quail-overlay 'face 'underline)
|
|
|
444 (let ((l (quail-overlay-plist)))
|
|
|
445 (while l
|
|
|
446 (overlay-put quail-overlay (car l) (car (cdr l)))
|
|
|
447 (setq l (cdr (cdr l))))))
|
|
|
448 (if (overlayp quail-conv-overlay)
|
|
|
449 (move-overlay quail-conv-overlay pos pos)
|
|
|
450 (setq quail-conv-overlay (make-overlay pos pos nil nil t))
|
|
|
451 (overlay-put quail-conv-overlay 'face 'underline)
|
|
|
452 ;;(overlay-put quail-conv-overlay 'modification-hooks
|
|
|
453 ;;'(quail-conv-overlay-modification-hook))
|
|
|
454 )))
|
|
|
455
|
|
|
456 ;; Delete overlays used in Quail mode.
|
|
|
457 (defun quail-delete-overlays ()
|
|
|
458 (if (overlayp quail-overlay)
|
|
|
459 (delete-overlay quail-overlay))
|
|
|
460 (if (overlayp quail-conv-overlay)
|
|
|
461 (delete-overlay quail-conv-overlay)))
|
|
|
462
|
|
|
463 ;; While translating and converting, we enter the recursive edit and
|
|
|
464 ;; exit it frequently, which results in frequent and annoying change
|
|
|
465 ;; of and annoying in mode line. To avoid it, we use a modified
|
|
|
466 ;; mode-line-format.
|
|
|
467 (defvar quail-mode-line-format nil)
|
|
|
468
|
|
|
469 ;; Return a modified mode-line-format which doesn't show the recursive
|
|
|
470 ;; editing level. But, we only pay attention to the top level
|
|
|
471 ;; elements of the current mode-line-format.
|
|
|
472 (defun quail-generate-mode-line-format ()
|
|
|
473 (if (listp mode-line-format)
|
|
|
474 (let ((new (copy-sequence mode-line-format))
|
|
|
475 l elt idx)
|
|
|
476 (setq l new)
|
|
|
477 (while l
|
|
|
478 (setq elt (car l))
|
|
|
479 (if (and (stringp elt)
|
|
|
480 (or (setq idx (string-match "%\\[" elt))
|
|
|
481 (setq idx (string-match "%\\]" elt))))
|
|
|
482 (setcar l (concat (substring elt 0 idx)
|
|
|
483 (substring elt (+ idx 2)))))
|
|
|
484 (setq l (cdr l)))
|
|
|
485 new)
|
|
|
486 mode-line-format))
|
|
|
487
|
|
|
488 (defun quail-mode (&optional arg)
|
|
|
489 "Toggle Quail minor mode.
|
|
|
490 With arg, turn Quail mode on if and only if arg is positive.
|
|
|
491 Try \\[describe-bindings] in Quail mode to see the available key binding.
|
|
|
492 The command \\[describe-input-method] describes the current Quail package."
|
|
|
493 (interactive "P")
|
|
|
494 (setq quail-mode
|
|
|
495 (if (null arg) (null quail-mode)
|
|
|
496 (> (prefix-numeric-value arg) 0)))
|
|
|
497 (if (null quail-mode)
|
|
|
498 ;; Let's turn off Quail mode.
|
|
|
499 (progn
|
|
|
500 (quail-hide-guidance-buf)
|
|
|
501 (quail-delete-overlays)
|
|
|
502 (setq describe-current-input-method-function nil)
|
|
|
503 (setq current-input-method nil)
|
|
|
504 (run-hooks 'quail-mode-exit-hook)
|
|
|
505 (run-hooks 'input-method-inactivate-hook))
|
|
|
506 ;; Let's turn on Quail mode.
|
|
|
507 ;; At first, be sure that quail-mode is at the first element of
|
|
|
508 ;; minor-mode-map-alist.
|
|
169
|
509 ;; The following code removed by slb because it corrupts the XEmacs
|
|
|
510 ;; minor-mode-map-alist
|
|
|
511 ; (or (eq (car minor-mode-map-alist) 'quail-mode)
|
|
|
512 ; (let ((l minor-mode-map-alist))
|
|
|
513 ; (while (cdr l)
|
|
|
514 ; (if (eq (car (cdr l)) 'quail-mode)
|
|
|
515 ; (progn
|
|
|
516 ; (setcdr l (cdr (cdr l)))
|
|
|
517 ; (setq l nil))
|
|
|
518 ; (setq l (cdr l))))
|
|
|
519 ; (setq minor-mode-map-alist (cons 'quail-mode minor-mode-map-alist))))
|
|
|
520 ;; End bogus code removal.
|
|
|
521 (delete-if (lambda (item) (eq (car item) 'quail-mode))
|
|
|
522 minor-mode-map-alist)
|
|
|
523 (setq minor-mode-map-alist
|
|
|
524 (cons (cons 'quail-mode quail-mode-map) minor-mode-map-alist))
|
|
|
525
|
|
155
|
526 (if (null quail-current-package)
|
|
|
527 ;; Quail package is not yet selected. Select one now.
|
|
|
528 (let (name)
|
|
|
529 (if quail-package-alist
|
|
|
530 (setq name (car (car quail-package-alist)))
|
|
|
531 (setq quail-mode nil)
|
|
|
532 (error "No Quail package loaded"))
|
|
|
533 (quail-select-package name)))
|
|
|
534 (setq inactivate-current-input-method-function 'quail-mode)
|
|
|
535 (setq describe-current-input-method-function 'quail-help)
|
|
|
536 (setq quail-mode-line-format (quail-generate-mode-line-format))
|
|
|
537 (quail-delete-overlays)
|
|
|
538 (quail-show-guidance-buf)
|
|
|
539 ;; If we are in minibuffer, turn off Quail mode before exiting.
|
|
|
540 (if (eq (selected-window) (minibuffer-window))
|
|
|
541 (add-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer))
|
|
|
542 (make-local-hook 'post-command-hook)
|
|
|
543 (run-hooks 'quail-mode-hook)
|
|
|
544 (run-hooks 'input-method-activate-hook))
|
|
|
545 (force-mode-line-update))
|
|
|
546
|
|
|
547 (defun quail-exit-from-minibuffer ()
|
|
|
548 (if quail-mode (quail-mode -1))
|
|
|
549 (if (<= (minibuffer-depth) 1)
|
|
|
550 (remove-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer)))
|
|
|
551
|
|
|
552 (defvar quail-saved-overriding-local-map nil)
|
|
|
553 (defvar quail-saved-current-buffer nil)
|
|
|
554
|
|
|
555 ;; Toggle `quail-mode'. This function is added to `post-command-hook'
|
|
|
556 ;; in Quail mode, to turn Quail mode temporarily off, or back on
|
|
|
557 ;; after one non-Quail command.
|
|
|
558 (defun quail-toggle-mode-temporarily ()
|
|
|
559 (if quail-mode
|
|
|
560 ;; We are going to handle following events out of Quail mode.
|
|
|
561 (setq quail-mode nil
|
|
|
562 quail-saved-overriding-local-map overriding-local-map
|
|
|
563 quail-saved-current-buffer (current-buffer)
|
|
|
564 overriding-local-map nil)
|
|
|
565 ;; We have just executed one non-Quail command. We don't need
|
|
|
566 ;; this hook any more.
|
|
|
567 (remove-hook 'post-command-hook 'quail-toggle-mode-temporarily t)
|
|
|
568 ;; If the command changed the current buffer, we should not go
|
|
|
569 ;; back to Quail mode.
|
|
|
570 (if (not (eq (current-buffer) quail-saved-current-buffer))
|
|
|
571 (throw 'quail-tag nil)
|
|
|
572 ;; Let's go back to Quail mode.
|
|
|
573 (setq quail-mode t)
|
|
|
574 (setq overriding-local-map quail-saved-overriding-local-map)
|
|
|
575 ;; If whole text in conversion area was deleted, exit from the
|
|
|
576 ;; recursive edit.
|
|
165
|
577 ;; 1997/6/24 modified by MORIOKA Tomohiko <morioka@jaist.ac.jp>
|
|
|
578 ;; for XEmacs
|
|
|
579 (let ((start (and quail-conv-overlay
|
|
|
580 (overlay-start quail-conv-overlay))))
|
|
155
|
581 (if (and start (= start (overlay-end quail-conv-overlay)))
|
|
|
582 (throw 'quail-tag nil)))
|
|
|
583 )))
|
|
|
584
|
|
|
585 (defun quail-execute-non-quail-command ()
|
|
|
586 "Execute one non-Quail command in Quail mode.
|
|
|
587 The current translation and conversion are terminated."
|
|
|
588 (interactive)
|
|
|
589 (setq unread-command-events (cons last-input-event unread-command-events))
|
|
|
590 (quail-delete-overlays)
|
|
|
591 (if (buffer-live-p quail-guidance-buf)
|
|
|
592 (save-excursion
|
|
|
593 (set-buffer quail-guidance-buf)
|
|
|
594 (erase-buffer)))
|
|
|
595 (throw 'quail-tag nil))
|
|
|
596
|
|
|
597 ;; Keyboard layout translation handlers.
|
|
|
598
|
|
|
599 ;; Some Quail packages provide localized keyboard simulation which
|
|
|
600 ;; requires a particular keyboard layout. In this case, what we need
|
|
|
601 ;; is locations of keys the user entered, not character codes
|
|
|
602 ;; generated by those keys. However, for the moment, there's no
|
|
|
603 ;; common way to get such information. So, we ask a user to give
|
|
|
604 ;; information of his own keyboard layout, then translate it to the
|
|
|
605 ;; standard layout which we defined so that all Quail packages depend
|
|
|
606 ;; just on it.
|
|
|
607
|
|
|
608 (defconst quail-keyboard-layout-standard
|
|
|
609 "\
|
|
|
610 \
|
|
|
611 1!2@3#4$5%6^7&8*9(0)-_=+`~ \
|
|
|
612 qQwWeErRtTyYuUiIoOpP[{]} \
|
|
|
613 aAsSdDfFgGhHjJkKlL;:'\"\\| \
|
|
|
614 zZxXcCvVbBnNmM,<.>/? \
|
|
|
615 "
|
|
|
616 "Standard keyboard layout of printable characters Quail assumes.
|
|
|
617 See the documentation of `quail-keyboard-layout' for this format.
|
|
|
618 This layout is almost the same as that of VT100,
|
|
|
619 but the location of key \\ (backslash) is just right of key ' (single-quote),
|
|
|
620 not right of RETURN key.")
|
|
|
621
|
|
|
622 (defvar quail-keyboard-layout quail-keyboard-layout-standard
|
|
|
623 "A string which represents physical key layout of a particular keyboard.
|
|
|
624 We assume there are six rows and each row has 15 keys (columns),
|
|
|
625 the first row is above the `1' - `0' row,
|
|
|
626 the first column of the second row is left of key `1',
|
|
|
627 the first column of the third row is left of key `q',
|
|
|
628 the first column of the fourth row is left of key `a',
|
|
|
629 the first column of the fifth row is left of key `z',
|
|
|
630 the sixth row is below the `z' - `/' row.
|
|
|
631 Nth (N is even) and (N+1)th characters in the string are non-shifted
|
|
|
632 and shifted characters respectively at the same location.
|
|
|
633 The location of Nth character is row (N / 30) and column ((N mod 30) / 2).")
|
|
|
634
|
|
|
635 (defconst quail-keyboard-layout-len 180)
|
|
|
636
|
|
|
637 ;; Here we provide several examples of famous keyboard layouts.
|
|
|
638
|
|
|
639 (defvar quail-keyboard-layout-alist
|
|
|
640 (list
|
|
|
641 '("sun-type3" . "\
|
|
|
642 \
|
|
|
643 1!2@3#4$5%6^7&8*9(0)-_=+\\|`~\
|
|
|
644 qQwWeErRtTyYuUiIoOpP[{]} \
|
|
|
645 aAsSdDfFgGhHjJkKlL;:'\" \
|
|
|
646 zZxXcCvVbBnNmM,<.>/? \
|
|
|
647 ")
|
|
|
648 (cons "standard" quail-keyboard-layout-standard))
|
|
|
649 "Alist of keyboard names and corresponding layout strings.
|
|
|
650 See the documentation of `quail-keyboard-layout' for the format of
|
|
|
651 the layout string.")
|
|
|
652
|
|
|
653 (defun quail-set-keyboard-layout (kbd-type)
|
|
|
654 "Set the current keyboard layout to the same as keyboard KBD-TYPE.
|
|
|
655
|
|
|
656 Since some Quail packages depends on a physical layout of keys (not
|
|
|
657 characters generated by them), those are created by assuming the
|
|
|
658 standard layout defined in `quail-keyboard-layout-standard'. This
|
|
|
659 function tells Quail system the layout of your keyboard so that what
|
|
|
660 you type is correctly handled."
|
|
|
661 (interactive
|
|
|
662 (let* ((completing-ignore-case t)
|
|
|
663 (type (completing-read "Keyboard type: "
|
|
|
664 quail-keyboard-layout-alist)))
|
|
|
665 (list type)))
|
|
|
666 (let ((layout (assoc kbd-type quail-keyboard-layout-alist)))
|
|
|
667 (if (null layout)
|
|
|
668 ;; Here, we had better ask a user to define his own keyboard
|
|
|
669 ;; layout interactively.
|
|
|
670 (error "Unknown keyboard type `%s'" kbd-type))
|
|
|
671 (setq quail-keyboard-layout (cdr layout))))
|
|
|
672
|
|
|
673 (defun quail-keyboard-translate (ch)
|
|
|
674 "Translate CHAR according to `quail-keyboard-layout' and return the result."
|
|
|
675 (if (eq quail-keyboard-layout quail-keyboard-layout-standard)
|
|
|
676 ch
|
|
|
677 (let ((i 0))
|
|
|
678 (while (and (< i quail-keyboard-layout-len)
|
|
|
679 (/= ch (aref quail-keyboard-layout i)))
|
|
|
680 (setq i (1+ i)))
|
|
|
681 (if (= i quail-keyboard-layout-len)
|
|
|
682 (error "Character `%c' not found in your keyboard layout" ch))
|
|
|
683 (aref quail-keyboard-layout-standard i))))
|
|
|
684
|
|
|
685 ;; Quail map
|
|
|
686
|
|
|
687 (defsubst quail-map-p (object)
|
|
|
688 "Return t if OBJECT is a Quail map.
|
|
|
689
|
|
|
690 A Quail map holds information how a particular key should be translated.
|
|
|
691 Its format is (TRANSLATION . ALIST).
|
|
|
692 TRANSLATION is either a character, or a cons (INDEX . VECTOR).
|
|
|
693 In the latter case, each element of VECTOR is a candidate for the translation,
|
|
|
694 and INDEX points the currently selected translation.
|
|
|
695
|
|
|
696 ALIST is normally a list of elements that look like (CHAR . DEFN),
|
|
|
697 where DEFN is another Quail map for a longer key (CHAR added to the
|
|
|
698 current key). It may also be a symbol of a function which returns an
|
|
|
699 alist of the above format.
|
|
|
700
|
|
|
701 Just after a Quail package is read, TRANSLATION may be a string or a
|
|
|
702 vector. Then each element of the string or vector is a candidate for
|
|
|
703 the translation. These objects are transformed to cons cells in the
|
|
|
704 format \(INDEX . VECTOR), as described above."
|
|
|
705 (and (consp object)
|
|
|
706 (let ((translation (car object)))
|
|
165
|
707 (or (characterp translation) (null translation)
|
|
155
|
708 (vectorp translation) (stringp translation)
|
|
165
|
709 (symbolp translation)
|
|
|
710 (and (consp translation) (not (vectorp (cdr translation))))))
|
|
155
|
711 (let ((alist (cdr object)))
|
|
165
|
712 (or (and (listp alist) (consp (car alist)))
|
|
|
713 (symbolp alist)))))
|
|
155
|
714
|
|
|
715 (defmacro quail-define-rules (&rest rules)
|
|
|
716 "Define translation rules of the current Quail package.
|
|
|
717 Each argument is a list of KEY and TRANSLATION.
|
|
|
718 KEY is a string meaning a sequence of keystrokes to be translated.
|
|
|
719 TRANSLATION is a character, a string, a vector, a Quail map, or a function.
|
|
|
720 It it is a character, it is the sole translation of KEY.
|
|
|
721 If it is a string, each character is a candidate for the translation.
|
|
|
722 If it is a vector, each element (string or character) is a candidate
|
|
|
723 for the translation.
|
|
|
724 In these cases, a key specific Quail map is generated and assigned to KEY.
|
|
|
725
|
|
|
726 If TRANSLATION is a Quail map or a function symbol which returns a Quail map,
|
|
|
727 it is used to handle KEY."
|
|
|
728 `(quail-install-map
|
|
|
729 ',(let ((l rules)
|
|
|
730 (map (list nil)))
|
|
|
731 (while l
|
|
|
732 (quail-defrule-internal (car (car l)) (car (cdr (car l))) map)
|
|
|
733 (setq l (cdr l)))
|
|
|
734 map)))
|
|
|
735
|
|
|
736 (defun quail-install-map (map)
|
|
|
737 "Install the Quail map MAP in the current Quail package.
|
|
|
738 The installed map can be referred by the function `quail-map'."
|
|
|
739 (if (null quail-current-package)
|
|
|
740 (error "No current Quail package"))
|
|
|
741 (if (null (quail-map-p map))
|
|
|
742 (error "Invalid Quail map `%s'" map))
|
|
|
743 (setcar (cdr (cdr quail-current-package)) map))
|
|
|
744
|
|
|
745 (defun quail-defrule (key translation &optional name)
|
|
|
746 "Add one translation rule, KEY to TRANSLATION, in the current Quail package.
|
|
|
747 KEY is a string meaning a sequence of keystrokes to be translated.
|
|
165
|
748 TRANSLATION is a character, a string, a vector, a Quail map,
|
|
|
749 a function, or a cons.
|
|
155
|
750 It it is a character, it is the sole translation of KEY.
|
|
|
751 If it is a string, each character is a candidate for the translation.
|
|
|
752 If it is a vector, each element (string or character) is a candidate
|
|
|
753 for the translation.
|
|
165
|
754 If it is a cons, the car is one of the above and the cdr is a function
|
|
|
755 to call when translating KEY.
|
|
155
|
756 In these cases, a key specific Quail map is generated and assigned to KEY.
|
|
|
757
|
|
|
758 If TRANSLATION is a Quail map or a function symbol which returns a Quail map,
|
|
|
759 it is used to handle KEY.
|
|
|
760 Optional argument NAME, if specified, says which Quail package
|
|
|
761 to define this translation rule in. The default is to define it in the
|
|
|
762 current Quail package."
|
|
|
763 (if name
|
|
|
764 (let ((package (quail-package name)))
|
|
|
765 (if (null package)
|
|
|
766 (error "No Quail package `%s'" name))
|
|
|
767 (setq quail-current-package package)))
|
|
|
768 (quail-defrule-internal key translation (quail-map)))
|
|
|
769
|
|
|
770 ;; Define KEY as TRANS in a Quail map MAP.
|
|
|
771 (defun quail-defrule-internal (key trans map)
|
|
|
772 (if (null (stringp key))
|
|
|
773 "Invalid Quail key `%s'" key)
|
|
|
774 ;; 1997/5/26 by MORIOKA Tomohiko
|
|
|
775 ;; modified for XEmacs
|
|
|
776 (if (not (or (characterp trans) (stringp trans) (vectorp trans)
|
|
165
|
777 (consp trans)
|
|
155
|
778 (symbolp trans)
|
|
|
779 (quail-map-p trans)))
|
|
|
780 (error "Invalid Quail translation `%s'" trans))
|
|
|
781 (if (null (quail-map-p map))
|
|
|
782 (error "Invalid Quail map `%s'" map))
|
|
|
783 (let ((len (length key))
|
|
|
784 (idx 0)
|
|
|
785 ch entry)
|
|
165
|
786 ;; Make a map for registering TRANS if necessary.
|
|
155
|
787 (while (< idx len)
|
|
|
788 (if (null (consp map))
|
|
|
789 ;; We come here, for example, when we try to define a rule
|
|
|
790 ;; for "ABC" but a rule for "AB" is already defined as a
|
|
|
791 ;; symbol.
|
|
|
792 (error "Quail key %s is too long" key))
|
|
|
793 (setq ch (aref key idx)
|
|
|
794 entry (assq ch (cdr map)))
|
|
|
795 (if (null entry)
|
|
|
796 (progn
|
|
|
797 (setq entry (cons ch (list nil)))
|
|
|
798 (setcdr map (cons entry (cdr map)))))
|
|
|
799 (setq map (cdr entry))
|
|
|
800 (setq idx (1+ idx)))
|
|
|
801 (if (symbolp trans)
|
|
|
802 (if (cdr map)
|
|
|
803 ;; We come here, for example, when we try to define a rule
|
|
|
804 ;; for "AB" as a symbol but a rule for "ABC" is already
|
|
|
805 ;; defined.
|
|
|
806 (error "Quail key %s is too short" key)
|
|
|
807 (setcdr entry trans))
|
|
|
808 (if (quail-map-p trans)
|
|
|
809 (if (not (listp (cdr map)))
|
|
|
810 ;; We come here, for example, when we try to define a rule
|
|
|
811 ;; for "AB" as a symbol but a rule for "ABC" is already
|
|
|
812 ;; defined.
|
|
|
813 (error "Quail key %s is too short" key)
|
|
|
814 (if (not (listp (cdr trans)))
|
|
|
815 (if (cdr map)
|
|
|
816 ;; We come here, for example, when we try to
|
|
|
817 ;; define a rule for "AB" as a symbol but a rule
|
|
|
818 ;; for "ABC" is already defined.
|
|
|
819 (error "Quail key %s is too short" key)
|
|
|
820 (setcdr entry trans))
|
|
|
821 (setcdr entry (append trans (cdr map)))))
|
|
|
822 (setcar map trans)))))
|
|
|
823
|
|
165
|
824 (defun quail-get-translation (def key len)
|
|
|
825 "Return the translation specified as DEF for KEY of length LEN.
|
|
155
|
826 The translation is either a character or a cons of the form (INDEX . VECTOR),
|
|
|
827 where VECTOR is a vector of candidates (character or string) for
|
|
|
828 the translation, and INDEX points into VECTOR to specify the currently
|
|
|
829 selected translation."
|
|
165
|
830 (if (and def (symbolp def))
|
|
|
831 ;; DEF is a symbol of a function which returns valid translation.
|
|
|
832 (setq def (funcall def key len)))
|
|
|
833 (if (and (consp def) (not (vectorp (cdr def))))
|
|
|
834 (setq def (car def)))
|
|
155
|
835
|
|
165
|
836 (cond
|
|
|
837 ((or (characterp def) (consp def))
|
|
|
838 def)
|
|
|
839
|
|
|
840 ((null def)
|
|
|
841 ;; No translation.
|
|
|
842 nil)
|
|
155
|
843
|
|
165
|
844 ((stringp def)
|
|
|
845 ;; Each character in DEF is a candidate of translation. Reform
|
|
|
846 ;; it as (INDEX . VECTOR).
|
|
|
847 (setq def (string-to-vector def))
|
|
|
848 ;; But if the length is 1, we don't need vector but a single
|
|
|
849 ;; candidate as the translation.
|
|
|
850 (if (= (length def) 1)
|
|
|
851 (aref def 0)
|
|
|
852 (cons 0 def)))
|
|
155
|
853
|
|
165
|
854 ((vectorp def)
|
|
|
855 ;; Each element (string or character) in DEF is a candidate of
|
|
|
856 ;; translation. Reform it as (INDEX . VECTOR).
|
|
|
857 (cons 0 def))
|
|
155
|
858
|
|
165
|
859 (t
|
|
|
860 (error "Invalid object in Quail map: %s" def))))
|
|
155
|
861
|
|
|
862 (defun quail-lookup-key (key len)
|
|
|
863 "Lookup KEY of length LEN in the current Quail map and return the definition.
|
|
|
864 The returned value is a Quail map specific to KEY."
|
|
|
865 (let ((idx 0)
|
|
|
866 (map (quail-map))
|
|
|
867 (kbd-translate (quail-kbd-translate))
|
|
165
|
868 slot ch translation def)
|
|
155
|
869 (while (and map (< idx len))
|
|
|
870 (setq ch (if kbd-translate (quail-keyboard-translate (aref key idx))
|
|
|
871 (aref key idx)))
|
|
|
872 (setq idx (1+ idx))
|
|
|
873 (if (and (cdr map) (symbolp (cdr map)))
|
|
|
874 (setcdr map (funcall (cdr map) key idx)))
|
|
|
875 (setq slot (assq ch (cdr map)))
|
|
|
876 (if (and (cdr slot) (symbolp (cdr slot)))
|
|
|
877 (setcdr slot (funcall (cdr slot) key idx)))
|
|
|
878 (setq map (cdr slot)))
|
|
165
|
879 (setq def (car map))
|
|
|
880 (if (and map (setq translation (quail-get-translation def key len)))
|
|
155
|
881 (progn
|
|
165
|
882 (if (and (consp def) (not (vectorp (cdr def))))
|
|
|
883 (progn
|
|
|
884 (if (not (equal (car def) translation))
|
|
|
885 ;; We must reflect TRANSLATION to car part of DEF.
|
|
|
886 (setcar def translation))
|
|
|
887 (setq quail-current-data
|
|
|
888 (if (functionp (cdr def))
|
|
|
889 (funcall (cdr def))
|
|
|
890 (cdr def))))
|
|
|
891 (if (not (equal def translation))
|
|
|
892 ;; We must reflect TRANSLATION to car part of MAP.
|
|
|
893 (setcar map translation)))
|
|
|
894 (if (and (consp translation) (vectorp (cdr translation)))
|
|
155
|
895 (progn
|
|
|
896 (setq quail-current-translations translation)
|
|
|
897 (if (quail-forget-last-selection)
|
|
|
898 (setcar quail-current-translations 0))))
|
|
|
899 ;; We may have to reform cdr part of MAP.
|
|
|
900 (if (and (cdr map) (symbolp (cdr map)))
|
|
|
901 (progn
|
|
|
902 (setcdr map (funcall (cdr map) key len))))
|
|
|
903 ))
|
|
|
904 map))
|
|
|
905
|
|
|
906 (defun quail-conv-overlay-modification-hook (overlay after &rest ignore)
|
|
|
907 (if (and after
|
|
|
908 (= (overlay-start overlay) (overlay-end overlay)))
|
|
|
909 ;; Whole text in conversion area was deleted. Let's exit from
|
|
|
910 ;; the recursive edit.
|
|
|
911 (throw 'exit nil)))
|
|
|
912
|
|
|
913 (defvar quail-suppress-conversion nil
|
|
|
914 "If non-nil, suppress converting facility of the current Quail package.")
|
|
|
915
|
|
|
916 ;; If set to non-nil, exit conversion mode before starting new translation.
|
|
|
917 (defvar quail-exit-conversion-mode nil)
|
|
|
918
|
|
|
919 (defun quail-start-translation ()
|
|
|
920 "Start translating the typed character in Quail mode."
|
|
|
921 (interactive "*")
|
|
|
922 (setq unread-command-events
|
|
|
923 (cons last-command-event unread-command-events))
|
|
|
924 ;; Check the possibility of translating the last key.
|
|
|
925 ;; 1997/5/26 by MORIOKA Tomohiko <morioka@jaist.ac.jp>
|
|
|
926 ;; modified for XEmacs
|
|
|
927 (if (assq (event-key last-command-event) (cdr (quail-map)))
|
|
|
928 ;; Ok, we can start translation.
|
|
|
929 (let ((mode-line-format quail-mode-line-format))
|
|
|
930 (quail-setup-overlays)
|
|
|
931 (if (catch 'quail-tag
|
|
|
932 (if (and (not quail-suppress-conversion)
|
|
|
933 (quail-conversion-keymap))
|
|
|
934 ;; We must start translation in conversion mode.
|
|
|
935 (let ((overriding-local-map (quail-conversion-keymap)))
|
|
|
936 (setq quail-exit-conversion-mode nil)
|
|
|
937 (recursive-edit)
|
|
|
938 (if (and auto-fill-function
|
|
|
939 (> (current-column) (current-fill-column)))
|
|
|
940 (run-hooks 'auto-fill-function)))
|
|
|
941 (let ((overriding-local-map (quail-translation-keymap)))
|
|
|
942 (setq quail-current-key "")
|
|
|
943 (recursive-edit)))
|
|
|
944 (let ((start (overlay-start quail-conv-overlay))
|
|
|
945 (end (overlay-end quail-conv-overlay)))
|
|
|
946 (if (and start end
|
|
|
947 (prog1 (< start end)
|
|
|
948 (delete-overlay quail-conv-overlay)))
|
|
|
949 (run-hooks 'input-method-after-insert-chunk-hook)))
|
|
|
950 nil)
|
|
|
951 ;; Someone has thrown a tag with value t, which means
|
|
|
952 ;; we should turn Quail mode off.
|
|
|
953 (quail-mode -1)))
|
|
|
954 ;; Since the typed character doesn't start any translation, handle
|
|
|
955 ;; it out of Quail mode. We come back to Quail mode later because
|
|
|
956 ;; function `quail-toggle-mode-temporarily' is in
|
|
|
957 ;; `post-command-hook'.
|
|
|
958 (add-hook 'post-command-hook 'quail-toggle-mode-temporarily nil t)))
|
|
|
959
|
|
|
960 (defsubst quail-point-in-conversion-region ()
|
|
|
961 "Return non-nil value if the point is in conversion region of Quail mode."
|
|
|
962 (let (start pos)
|
|
|
963 (and (setq start (overlay-start quail-conv-overlay))
|
|
|
964 (>= (setq pos (point)) start)
|
|
|
965 (<= pos (overlay-end quail-conv-overlay)))))
|
|
|
966
|
|
|
967 (defun quail-start-translation-in-conversion-mode ()
|
|
|
968 "Start translating the typed character in conversion mode of Quail mode."
|
|
|
969 (interactive "*")
|
|
|
970 (setq unread-command-events
|
|
|
971 (cons last-command-event unread-command-events))
|
|
|
972 (if (or quail-exit-conversion-mode
|
|
|
973 (not (quail-point-in-conversion-region)))
|
|
|
974 (progn
|
|
|
975 ;; We must start translation with new conversion region.
|
|
|
976 (setq quail-exit-conversion-mode nil)
|
|
|
977 (throw 'exit nil)))
|
|
|
978 ;; Check the possibility of translating the last key.
|
|
|
979 ;; 1997/5/26 by MORIOKA Tomohiko <morioka@jaist.ac.jp>
|
|
|
980 ;; modified for XEmacs
|
|
|
981 (if (assq (event-key last-command-event) (cdr (quail-map)))
|
|
|
982 ;; Ok, we can start translation.
|
|
|
983 (let ((overriding-local-map (quail-translation-keymap)))
|
|
|
984 (setq quail-current-key "")
|
|
|
985 (move-overlay quail-overlay (point) (point))
|
|
|
986 (recursive-edit))
|
|
|
987 ;; Since the typed character doesn't start any translation, handle
|
|
|
988 ;; it out of Quail mode. We come back to Quail mode later because
|
|
|
989 ;; function `quail-toggle-mode-temporarily' is in
|
|
|
990 ;; `post-command-hook'.
|
|
|
991 (add-hook 'post-command-hook 'quail-toggle-mode-temporarily nil t)))
|
|
|
992
|
|
|
993 (defun quail-terminate-translation ()
|
|
|
994 "Terminate the translation of the current key."
|
|
|
995 (let ((start (overlay-start quail-overlay)))
|
|
|
996 (if (and start
|
|
|
997 (< start (overlay-end quail-overlay)))
|
|
|
998 ;; Here we simulate self-insert-command.
|
|
|
999 (let (last-command-char)
|
|
|
1000 (goto-char start)
|
|
|
1001 ;; The first one might want to expand an abbrev.
|
|
|
1002 (setq last-command-char (following-char))
|
|
|
1003 (delete-char 1)
|
|
|
1004 (self-insert-command 1)
|
|
|
1005 (let ((end (overlay-end quail-overlay)))
|
|
|
1006 (if (and end (< (point) end))
|
|
|
1007 (if overwrite-mode
|
|
|
1008 (while (< (point) end)
|
|
|
1009 (setq last-command-char (following-char))
|
|
|
1010 (delete-char 1)
|
|
|
1011 (self-insert-command 1))
|
|
|
1012 ;; The last one might still want to auto-fill.
|
|
|
1013 (goto-char end)
|
|
|
1014 (let ((last-command-char (preceding-char)))
|
|
|
1015 (delete-char -1)
|
|
|
1016 (self-insert-command 1))))))))
|
|
|
1017 (delete-overlay quail-overlay)
|
|
|
1018 (if (buffer-live-p quail-guidance-buf)
|
|
|
1019 (save-excursion
|
|
|
1020 (set-buffer quail-guidance-buf)
|
|
|
1021 (erase-buffer)))
|
|
|
1022 (throw 'exit nil))
|
|
|
1023
|
|
|
1024 (defsubst quail-delete-region ()
|
|
|
1025 "Delete the text in the current translation region of Quail."
|
|
|
1026 (let ((start (overlay-start quail-overlay))
|
|
|
1027 (end (overlay-end quail-overlay)))
|
|
|
1028 (and start end (delete-region start end))))
|
|
|
1029
|
|
|
1030 (defun quail-select-current ()
|
|
|
1031 "Select the current text shown in Quail translation region."
|
|
|
1032 (interactive)
|
|
|
1033 (quail-terminate-translation))
|
|
|
1034
|
|
|
1035 ;; Update the current translation status according to CONTROL-FLAG.
|
|
|
1036 ;; If CONTROL-FLAG is integer value, it is the number of keys in the
|
|
|
1037 ;; head quail-current-key which can be translated. The remaining keys
|
|
|
1038 ;; are put back to unread-command-events to be handled again.
|
|
|
1039 ;; If CONTROL-FLAG is t, terminate the translation for the whole keys
|
|
|
1040 ;; in quail-current-key.
|
|
|
1041 ;; If CONTROL-FLAG is nil, proceed the translation with more keys.
|
|
|
1042
|
|
|
1043 (defun quail-update-translation (control-flag)
|
|
|
1044 (quail-delete-region)
|
|
|
1045 (let ((func (quail-update-translation-function)))
|
|
|
1046 (if func
|
|
|
1047 (funcall func control-flag)
|
|
|
1048 (if (numberp control-flag)
|
|
|
1049 (let ((len (length quail-current-key)))
|
|
|
1050 (while (> len control-flag)
|
|
|
1051 (setq len (1- len))
|
|
|
1052 (setq unread-command-events
|
|
|
1053 ;; 1997/5/26 by MORIOKA Tomohiko
|
|
|
1054 ;; modified for XEmacs
|
|
|
1055 (cons (character-to-event (aref quail-current-key len))
|
|
|
1056 unread-command-events)))
|
|
|
1057 (insert (or quail-current-str
|
|
|
1058 (substring quail-current-key 0 len))))
|
|
|
1059 (insert (or quail-current-str quail-current-key)))))
|
|
|
1060 (quail-update-guidance)
|
|
|
1061 (if control-flag
|
|
|
1062 (quail-terminate-translation)))
|
|
|
1063
|
|
|
1064 (defun quail-self-insert-command ()
|
|
|
1065 "Add the typed character to the key for translation."
|
|
|
1066 (interactive "*")
|
|
|
1067 ;; 1997/5/26 by MORIOKA Tomohiko <morioka@jaist.ac.jp>
|
|
|
1068 ;; modified for XEmacs
|
|
|
1069 (setq quail-current-key
|
|
|
1070 (concat quail-current-key (char-to-string
|
|
|
1071 (event-to-character last-command-event))))
|
|
|
1072 (quail-update-translation (quail-translate-key)))
|
|
|
1073
|
|
|
1074 (defun quail-translate-key ()
|
|
|
1075 "Translate the current key sequence according to the current Quail map.
|
|
|
1076 Return t if we can terminate the translation.
|
|
|
1077 Return nil if the current key sequence may be followed by more keys.
|
|
|
1078 Return number if we can't find any translation for the current key
|
|
|
1079 sequence. The number is the count of valid keys in the current
|
|
|
1080 sequence counting from the head."
|
|
|
1081 (let* ((len (length quail-current-key))
|
|
|
1082 (map (quail-lookup-key quail-current-key len))
|
|
|
1083 def ch)
|
|
|
1084 (if map
|
|
|
1085 (let ((def (car map)))
|
|
165
|
1086 (if (and (consp def) (not (vectorp (cdr def))))
|
|
|
1087 (setq def (car def)))
|
|
155
|
1088 (setq quail-current-str
|
|
|
1089 (if (consp def) (aref (cdr def) (car def)) def))
|
|
|
1090 ;; Return t only if we can terminate the current translation.
|
|
|
1091 (and
|
|
|
1092 ;; No alternative translations.
|
|
|
1093 (or (null (consp def)) (= (length (cdr def)) 1))
|
|
|
1094 ;; No translation for the longer key.
|
|
|
1095 (null (cdr map))
|
|
|
1096 ;; No shorter breaking point.
|
|
|
1097 (or (null (quail-maximum-shortest))
|
|
|
1098 (< len 3)
|
|
|
1099 (null (quail-lookup-key quail-current-key (1- len)))
|
|
|
1100 (null (quail-lookup-key
|
|
|
1101 (substring quail-current-key -2 -1) 1)))))
|
|
|
1102
|
|
|
1103 ;; There's no translation for the current key sequence. Before
|
|
|
1104 ;; giving up, we must check two possibilities.
|
|
|
1105 (cond ((and
|
|
|
1106 (quail-maximum-shortest)
|
|
|
1107 (>= len 4)
|
|
|
1108 (setq def (car (quail-lookup-key quail-current-key (- len 2))))
|
|
165
|
1109 (if (and (consp def) (not (vectorp (cdr def))))
|
|
|
1110 (setq def (car def)))
|
|
155
|
1111 (quail-lookup-key (substring quail-current-key -2) 2))
|
|
|
1112 ;; Now the sequence is "...ABCD", which can be split into
|
|
|
1113 ;; "...AB" and "CD..." to get valid translation.
|
|
|
1114 ;; At first, get translation of "...AB".
|
|
|
1115 (setq quail-current-str
|
|
|
1116 (if (consp def) (aref (cdr def) (car def)) def))
|
|
|
1117 ;; Then, return the length of "...AB".
|
|
|
1118 (- len 2))
|
|
|
1119
|
|
|
1120 ((and quail-current-translations
|
|
|
1121 (not (quail-deterministic))
|
|
|
1122 (setq ch (aref quail-current-key (1- len)))
|
|
|
1123 (>= ch ?0) (<= ch ?9))
|
|
|
1124 ;; A numeric key is entered to select a desirable translation.
|
|
|
1125 (setq quail-current-key (substring quail-current-key 0 -1))
|
|
|
1126 (quail-select-translation
|
|
|
1127 (+ (* (/ (car quail-current-translations) 10) 10)
|
|
|
1128 ;; We treat key 1,2..,9,0 as specifying 0,1,..8,9.
|
|
|
1129 (if (= ch ?0) 9 (- ch ?1))))
|
|
|
1130 ;; And, we can terminate the current translation.
|
|
|
1131 t)
|
|
|
1132
|
|
|
1133 (t
|
|
|
1134 ;; No way to handle the last character in this context.
|
|
|
1135 (1- len))))))
|
|
|
1136
|
|
|
1137 (defun quail-next-translation ()
|
|
|
1138 "Select next translation in the current batch of candidates."
|
|
|
1139 (interactive)
|
|
|
1140 (if quail-current-translations
|
|
|
1141 (progn
|
|
|
1142 (quail-select-translation (1+ (car quail-current-translations)))
|
|
|
1143 (quail-update-translation nil))
|
|
|
1144 (beep)))
|
|
|
1145
|
|
|
1146 (defun quail-prev-translation ()
|
|
|
1147 "Select previous translation in the current batch of candidates."
|
|
|
1148 (interactive)
|
|
|
1149 (if quail-current-translations
|
|
|
1150 (progn
|
|
|
1151 (quail-select-translation (1- (car quail-current-translations)))
|
|
|
1152 (quail-update-translation nil))
|
|
|
1153 (beep)))
|
|
|
1154
|
|
|
1155 (defun quail-next-translation-block ()
|
|
|
1156 "Select the next batch of 10 translation candidates."
|
|
|
1157 (interactive)
|
|
|
1158 (if quail-current-translations
|
|
|
1159 (let ((limit (1- (length (cdr quail-current-translations))))
|
|
|
1160 (n (car quail-current-translations)))
|
|
|
1161 (if (< (/ n 10) (/ limit 10))
|
|
|
1162 (progn
|
|
|
1163 (quail-select-translation (min (+ n 10) limit))
|
|
|
1164 (quail-update-translation nil))
|
|
|
1165 ;; We are already at the last block.
|
|
|
1166 (beep)))
|
|
|
1167 (beep)))
|
|
|
1168
|
|
|
1169 (defun quail-prev-translation-block ()
|
|
|
1170 "Select the previous batch of 10 translation candidates."
|
|
|
1171 (interactive)
|
|
|
1172 (if (and quail-current-translations
|
|
|
1173 (>= (car quail-current-translations) 10))
|
|
|
1174 (progn
|
|
|
1175 (quail-select-translation (- (car quail-current-translations) 10))
|
|
|
1176 (quail-update-translation nil))
|
|
|
1177 (beep)))
|
|
|
1178
|
|
|
1179 (defun quail-select-translation (n)
|
|
|
1180 "Select Nth translation in the current batch of translation candidates."
|
|
|
1181 (if (or (< n 0) (>= n (length (cdr quail-current-translations))))
|
|
|
1182 (beep)
|
|
|
1183 (setcar quail-current-translations n)
|
|
|
1184 (setq quail-current-str (aref (cdr quail-current-translations) n))))
|
|
|
1185
|
|
|
1186 (defun quail-abort-translation ()
|
|
|
1187 "Abort translation and delete the current Quail key sequence."
|
|
|
1188 (interactive)
|
|
|
1189 (quail-delete-region)
|
|
|
1190 (quail-terminate-translation))
|
|
|
1191
|
|
|
1192 (defun quail-delete-last-char ()
|
|
|
1193 "Delete the last input character from the current Quail key sequence."
|
|
|
1194 (interactive)
|
|
|
1195 (if (= (length quail-current-key) 1)
|
|
|
1196 (quail-abort-translation)
|
|
|
1197 (setq quail-current-key (substring quail-current-key 0 -1))
|
|
|
1198 (quail-update-translation (quail-translate-key))))
|
|
|
1199
|
|
|
1200 ;; For conversion mode.
|
|
|
1201
|
|
|
1202 (defun quail-conversion-backward-char ()
|
|
|
1203 (interactive)
|
|
|
1204 (if (<= (point) (overlay-start quail-conv-overlay))
|
|
|
1205 (error "Beginning of conversion region"))
|
|
|
1206 (forward-char -1))
|
|
|
1207
|
|
|
1208 (defun quail-conversion-forward-char ()
|
|
|
1209 (interactive)
|
|
|
1210 (if (>= (point) (overlay-end quail-conv-overlay))
|
|
|
1211 (error "End of conversion region"))
|
|
|
1212 (forward-char 1))
|
|
|
1213
|
|
|
1214 (defun quail-conversion-beginning-of-region ()
|
|
|
1215 (interactive)
|
|
|
1216 (goto-char (overlay-start quail-conv-overlay)))
|
|
|
1217
|
|
|
1218 (defun quail-conversion-end-of-region ()
|
|
|
1219 (interactive)
|
|
|
1220 (goto-char (overlay-end quail-conv-overlay)))
|
|
|
1221
|
|
|
1222 (defun quail-conversion-delete-char ()
|
|
|
1223 (interactive)
|
|
|
1224 (if (>= (point) (overlay-end quail-conv-overlay))
|
|
|
1225 (error "End of conversion region"))
|
|
|
1226 (delete-char 1)
|
|
|
1227 (if (= (overlay-start quail-conv-overlay)
|
|
|
1228 (overlay-end quail-conv-overlay))
|
|
|
1229 (throw 'quail-tag nil)))
|
|
|
1230
|
|
|
1231 (defun quail-conversion-backward-delete-char ()
|
|
|
1232 (interactive)
|
|
|
1233 (if (<= (point) (overlay-start quail-conv-overlay))
|
|
|
1234 (error "Beginning of conversion region"))
|
|
|
1235 (delete-char -1)
|
|
|
1236 (if (= (overlay-start quail-conv-overlay)
|
|
|
1237 (overlay-end quail-conv-overlay))
|
|
|
1238 (throw 'quail-tag nil)))
|
|
|
1239
|
|
|
1240 (defun quail-do-conversion (func &rest args)
|
|
|
1241 "Call FUNC to convert text in the current conversion region of Quail.
|
|
|
1242 Remaining args are for FUNC."
|
|
|
1243 (delete-overlay quail-overlay)
|
|
|
1244 (apply func args))
|
|
|
1245
|
|
|
1246 (defun quail-no-conversion ()
|
|
|
1247 "Do no conversion of the current conversion region of Quail."
|
|
|
1248 (interactive)
|
|
|
1249 (throw 'exit nil))
|
|
|
1250
|
|
|
1251 ;; Guidance, Completion, and Help buffer handlers.
|
|
|
1252
|
|
|
1253 (defun quail-show-guidance-buf ()
|
|
|
1254 "Display a Quail guidance buffer in some window.
|
|
|
1255 Create the buffer if it does not exist yet.
|
|
|
1256 The window is normally shown in a minibuffer,
|
|
|
1257 but if the selected window is a minibuffer, it is shown in
|
|
|
1258 the bottommost ordinary window."
|
|
|
1259
|
|
|
1260 (if (or (null input-method-tersely-flag)
|
|
|
1261 (not (eq (selected-window) (minibuffer-window))))
|
|
|
1262 (progn
|
|
|
1263 ;; At first, setup a guidance buffer.
|
|
|
1264 (or (buffer-live-p quail-guidance-buf)
|
|
|
1265 (setq quail-guidance-buf
|
|
|
1266 (get-buffer-create " *Quail-guidance*")))
|
|
|
1267 (save-excursion
|
|
|
1268 (let ((title (quail-title)))
|
|
|
1269 (set-buffer quail-guidance-buf)
|
|
|
1270 ;; Show the title of Quail package in the left of mode-line.
|
|
|
1271 (setq current-input-method nil)
|
|
|
1272 (setq current-input-method-title title)
|
|
|
1273 (setq mode-line-format (cons '("[" current-input-method-title "]")
|
|
|
1274 default-mode-line-format))
|
|
|
1275 (erase-buffer)
|
|
|
1276 (or (overlayp quail-overlay)
|
|
|
1277 (progn
|
|
|
1278 (setq quail-overlay (make-overlay 1 1))
|
|
|
1279 (overlay-put quail-overlay 'face 'highlight)))
|
|
|
1280 (delete-overlay quail-overlay)
|
|
|
1281 (set-buffer-modified-p nil)))
|
|
|
1282 (bury-buffer quail-guidance-buf)
|
|
|
1283
|
|
|
1284 ;; Then, display it in an appropriate window.
|
|
|
1285 (if (not (get-buffer-window quail-guidance-buf))
|
|
|
1286 ;; Guidance buffer is not yet shown in any window.
|
|
|
1287 (let ((win (minibuffer-window)))
|
|
|
1288 (if (eq (selected-window) win)
|
|
|
1289 ;; Since we are in minibuffer, we can't use it for guidance.
|
|
|
1290 ;; Let's find the bottom window.
|
|
|
1291 (let (height)
|
|
|
1292 (setq win (window-at 0 (- (frame-height) 2)))
|
|
|
1293 (setq height (window-height win))
|
|
|
1294 ;; If WIN is too tall, split it vertically and use
|
|
|
1295 ;; the lower one.
|
|
|
1296 (if (>= height 4)
|
|
|
1297 (let ((window-min-height 2))
|
|
|
1298 ;; Here, `split-window' returns a lower window
|
|
|
1299 ;; which is what we wanted.
|
|
|
1300 (setq win (split-window win (- height 2)))))
|
|
|
1301 (set-window-buffer win quail-guidance-buf)
|
|
|
1302 (set-window-dedicated-p win t))
|
|
|
1303 (set-window-buffer win quail-guidance-buf))))))
|
|
|
1304
|
|
|
1305 ;; And, create a buffer for completion.
|
|
|
1306 (or (buffer-live-p quail-completion-buf)
|
|
|
1307 (progn
|
|
|
1308 (setq quail-completion-buf (get-buffer-create "*Quail Completions*"))
|
|
|
1309 (save-excursion
|
|
|
1310 (set-buffer quail-completion-buf)
|
|
|
1311 (setq quail-overlay (make-overlay 1 1))
|
|
|
1312 (overlay-put quail-overlay 'face 'highlight))))
|
|
|
1313 (bury-buffer quail-completion-buf))
|
|
|
1314
|
|
|
1315 (defun quail-hide-guidance-buf ()
|
|
|
1316 "Hide the Quail guidance buffer."
|
|
|
1317 (let* ((win (minibuffer-window))
|
|
|
1318 (buf (window-buffer win)))
|
|
|
1319 (if (eq buf quail-guidance-buf)
|
|
|
1320 ;; Quail guidance buffer is at echo area. Vacate it to the
|
|
|
1321 ;; deepest minibuffer.
|
|
|
1322 (set-window-buffer win (format " *Minibuf-%d*" (minibuffer-depth)))
|
|
|
1323 ;; Delete the window for guidance buffer.
|
|
|
1324 (if (or (null input-method-tersely-flag)
|
|
|
1325 (not (eq (selected-window) (minibuffer-window))))
|
|
|
1326 (progn
|
|
|
1327 (setq win (get-buffer-window quail-guidance-buf))
|
|
|
1328 (set-window-dedicated-p win nil)
|
|
|
1329 (delete-window win))))))
|
|
|
1330
|
|
|
1331 (defun quail-update-guidance ()
|
|
|
1332 "Update the Quail guidance buffer and completion buffer (if displayed now)."
|
|
|
1333 ;; Update guidance buffer.
|
|
|
1334 (if (or (null input-method-tersely-flag)
|
|
|
1335 (not (eq (selected-window) (minibuffer-window))))
|
|
|
1336 (let ((guidance (quail-guidance)))
|
|
|
1337 (cond ((eq guidance t)
|
|
|
1338 ;; Show the current possible translations.
|
|
|
1339 (quail-show-translations))
|
|
|
1340 ((null guidance)
|
|
|
1341 ;; Show the current input keys.
|
|
|
1342 (let ((key quail-current-key))
|
|
|
1343 (save-excursion
|
|
|
1344 (set-buffer quail-guidance-buf)
|
|
|
1345 (erase-buffer)
|
|
|
1346 (insert key))))
|
|
|
1347 ((listp guidance)
|
|
|
1348 ;; Show alternative characters specified in this alist.
|
|
|
1349 (let* ((key quail-current-key)
|
|
|
1350 (len (length key))
|
|
|
1351 (i 0)
|
|
|
1352 ch alternative)
|
|
|
1353 (save-excursion
|
|
|
1354 (set-buffer quail-guidance-buf)
|
|
|
1355 (erase-buffer)
|
|
|
1356 (while (< i len)
|
|
|
1357 (setq ch (aref key i))
|
|
|
1358 (setq alternative (cdr (assoc ch guidance)))
|
|
|
1359 (insert (or alternative ch))
|
|
|
1360 (setq i (1+ i)))))))))
|
|
|
1361
|
|
|
1362 ;; Update completion buffer if displayed now. We highlight the
|
|
|
1363 ;; selected candidate string in *Completion* buffer if any.
|
|
|
1364 (let ((win (get-buffer-window quail-completion-buf))
|
|
|
1365 key str pos)
|
|
|
1366 (if win
|
|
|
1367 (save-excursion
|
|
|
1368 (setq str (if (stringp quail-current-str)
|
|
|
1369 quail-current-str
|
|
|
1370 (if (numberp quail-current-str)
|
|
|
1371 (char-to-string quail-current-str)))
|
|
|
1372 key quail-current-key)
|
|
|
1373 (set-buffer quail-completion-buf)
|
|
|
1374 (goto-char (point-min))
|
|
|
1375 (if (null (search-forward (concat " " key ":") nil t))
|
|
|
1376 (delete-overlay quail-overlay)
|
|
|
1377 (setq pos (point))
|
|
|
1378 (if (and str (search-forward (concat "." str) nil t))
|
|
|
1379 (move-overlay quail-overlay (1+ (match-beginning 0)) (point))
|
|
|
1380 (move-overlay quail-overlay (match-beginning 0) (point)))
|
|
|
1381 ;; Now POS points end of KEY and (point) points end of STR.
|
|
|
1382 (if (pos-visible-in-window-p (point) win)
|
|
|
1383 ;; STR is already visible.
|
|
|
1384 nil
|
|
|
1385 ;; We want to make both KEY and STR visible, but if the
|
|
|
1386 ;; window is too short, make at least STR visible.
|
|
|
1387 (setq pos (progn (point) (goto-char pos)))
|
|
|
1388 (beginning-of-line)
|
|
|
1389 (set-window-start win (point))
|
|
|
1390 (if (not (pos-visible-in-window-p pos win))
|
|
|
1391 (set-window-start win pos))
|
|
|
1392 ))))))
|
|
|
1393
|
|
|
1394 (defun quail-show-translations ()
|
|
|
1395 "Show the current possible translations."
|
|
165
|
1396 (let* ((key quail-current-key)
|
|
|
1397 (map (quail-lookup-key quail-current-key (length quail-current-key)))
|
|
|
1398 (def (car map)))
|
|
|
1399 (if (and (consp def) (not (vectorp (cdr def))))
|
|
|
1400 (setq def (car def)))
|
|
155
|
1401 (save-excursion
|
|
|
1402 (set-buffer quail-guidance-buf)
|
|
|
1403 (erase-buffer)
|
|
|
1404
|
|
|
1405 ;; Show the current key.
|
|
|
1406 (insert key)
|
|
|
1407
|
|
|
1408 ;; Show possible following keys.
|
|
|
1409 (if (cdr map)
|
|
|
1410 (let ((l (cdr map)))
|
|
|
1411 (insert "[")
|
|
|
1412 (while l
|
|
|
1413 (insert (car (car l)))
|
|
|
1414 (setq l (cdr l)))
|
|
|
1415 (insert "]")))
|
|
|
1416
|
|
|
1417 ;; Show list of translations.
|
|
165
|
1418 (if (and (not (quail-deterministic)) (consp def))
|
|
|
1419 (let* ((idx (car def))
|
|
|
1420 (translations (cdr def))
|
|
155
|
1421 (from (* (/ idx 10) 10))
|
|
|
1422 (to (min (+ from 10) (length translations))))
|
|
|
1423 (indent-to 10)
|
|
|
1424 (insert (format "(%d/%d)"
|
|
|
1425 (1+ (/ from 10))
|
|
|
1426 (1+ (/ (length translations) 10))))
|
|
|
1427 (while (< from to)
|
|
|
1428 ;; We show the last digit of FROM, but by changing
|
|
|
1429 ;; 0,1,..,9 to 1,2,..,0.
|
|
|
1430 (insert (format " %d."
|
|
|
1431 (if (= (% from 10) 9) 0 (1+ (% from 10)))))
|
|
|
1432 (let ((pos (point)))
|
|
|
1433 (insert (aref translations from))
|
|
|
1434 (if (= idx from)
|
|
|
1435 (move-overlay quail-overlay pos (point))))
|
|
|
1436 (setq from (1+ from)))))
|
|
|
1437 )))
|
|
|
1438
|
|
|
1439 (defun quail-completion ()
|
|
|
1440 "List all completions for the current key.
|
|
|
1441 All possible translations of the current key and whole possible longer keys
|
|
|
1442 are shown."
|
|
|
1443 (interactive)
|
|
|
1444 (let ((key quail-current-key)
|
|
|
1445 (map (quail-lookup-key quail-current-key (length quail-current-key))))
|
|
|
1446 (save-excursion
|
|
|
1447 (set-buffer quail-completion-buf)
|
|
|
1448 (erase-buffer)
|
|
|
1449 (insert "Possible completion and corresponding translations are:\n")
|
|
|
1450 (quail-completion-1 key map 1)
|
|
|
1451 (goto-char (point-min))
|
|
|
1452 (display-buffer (current-buffer)))
|
|
|
1453 (quail-update-guidance)))
|
|
|
1454
|
|
|
1455 ;; List all completions of KEY in MAP with indentation INDENT.
|
|
|
1456 (defun quail-completion-1 (key map indent)
|
|
|
1457 (let ((len (length key)))
|
|
|
1458 (indent-to indent)
|
|
|
1459 (insert key ":")
|
|
|
1460 (if (and (symbolp map) (fboundp map))
|
|
|
1461 (setq map (funcall map key len)))
|
|
|
1462 (if (car map)
|
|
|
1463 (quail-completion-list-translations map key (+ indent len 1))
|
|
|
1464 (insert " -\n"))
|
|
|
1465 (setq indent (+ indent 2))
|
|
|
1466 (if (cdr map)
|
|
|
1467 (let ((l (cdr map))
|
|
|
1468 (newkey (make-string (1+ len) 0))
|
|
|
1469 (i 0))
|
|
|
1470 ;; Set KEY in the first LEN characters of NEWKEY.
|
|
|
1471 (while (< i len)
|
|
|
1472 (aset newkey i (aref key i))
|
|
|
1473 (setq i (1+ i)))
|
|
|
1474 (while l ; L = ((CHAR . DEFN) ....) ;
|
|
|
1475 (aset newkey len (car (car l)))
|
|
|
1476 (quail-completion-1 newkey (cdr (car l)) indent)
|
|
|
1477 (setq l (cdr l)))))))
|
|
|
1478
|
|
|
1479 ;; List all possible translations of KEY in Quail map MAP with
|
|
165
|
1480 ;; indentation INDENT.
|
|
155
|
1481 (defun quail-completion-list-translations (map key indent)
|
|
|
1482 (let ((translations
|
|
165
|
1483 (quail-get-translation (car map) key (length key))))
|
|
177
|
1484 (if (characterp translations)
|
|
155
|
1485 (insert "(1/1) 1." translations "\n")
|
|
|
1486 ;; We need only vector part.
|
|
|
1487 (setq translations (cdr translations))
|
|
|
1488 ;; Insert every 10 elements with indices in a line.
|
|
|
1489 (let ((len (length translations))
|
|
|
1490 (i 0)
|
|
|
1491 (first t)
|
|
|
1492 num)
|
|
|
1493 (while (< i len)
|
|
|
1494 (if first
|
|
|
1495 (progn
|
|
|
1496 (insert "(1/1)")
|
|
|
1497 (setq first nil))
|
|
|
1498 (if (= (% i 10) 0)
|
|
|
1499 (progn
|
|
|
1500 (newline)
|
|
|
1501 (indent-to indent)
|
|
|
1502 (insert (format "(%d/%d)" (1+ (/ i 10)) (1+ (/ len 10)))))))
|
|
|
1503 ;; We show the last digit of FROM while converting
|
|
|
1504 ;; 0,1,..,9 to 1,2,..,0.
|
|
|
1505 (insert (format " %d." (if (= (% i 10) 9) 0 (1+ (% i 10)))))
|
|
|
1506 (insert (aref translations i))
|
|
|
1507 (setq i (1+ i)))
|
|
|
1508 (newline)))))
|
|
|
1509
|
|
|
1510 (defun quail-help ()
|
|
|
1511 "Show brief description of the current Quail package."
|
|
|
1512 (interactive)
|
|
|
1513 (let ((package quail-current-package)
|
|
|
1514 (buf (get-buffer-create "*Quail-help*")))
|
|
|
1515 (save-excursion
|
|
|
1516 (set-buffer buf)
|
|
|
1517 (erase-buffer)
|
|
|
1518 (setq quail-current-package package)
|
|
|
1519 (insert "Quail input method (name:"
|
|
|
1520 (quail-name)
|
|
|
1521 ", mode line indicator:["
|
|
|
1522 (quail-title)
|
|
|
1523 "])\n---- Documentation ----\n"
|
|
|
1524 (quail-docstring))
|
|
|
1525 (newline)
|
|
|
1526 (if (quail-show-layout) (quail-show-kbd-layout))
|
|
|
1527 (insert )
|
|
|
1528 (quail-help-insert-keymap-description
|
|
|
1529 quail-mode-map
|
|
|
1530 "---- Key bindings (before starting translation) ----
|
|
|
1531 key binding
|
|
|
1532 --- -------\n")
|
|
|
1533 (quail-help-insert-keymap-description
|
|
|
1534 (quail-translation-keymap)
|
|
|
1535 "--- Key bindings (while translating) ---
|
|
|
1536 key binding
|
|
|
1537 --- -------\n")
|
|
|
1538 (if (quail-conversion-keymap)
|
|
|
1539 (quail-help-insert-keymap-description
|
|
|
1540 (quail-conversion-keymap)
|
|
|
1541 "--- Key bindings (while converting) ---
|
|
|
1542 key binding
|
|
|
1543 --- -------\n"))
|
|
|
1544 (goto-char (point-min))
|
|
|
1545 (set-buffer-modified-p nil)
|
|
|
1546 (help-mode))
|
|
|
1547 (display-buffer buf)))
|
|
|
1548
|
|
|
1549 (defun quail-help-insert-keymap-description (keymap &optional header)
|
|
|
1550 (let (from to)
|
|
|
1551 (if header
|
|
|
1552 (insert header))
|
|
|
1553 (save-excursion
|
|
|
1554 (save-window-excursion
|
|
|
1555 (let ((overriding-local-map keymap))
|
|
|
1556 (describe-bindings))
|
|
|
1557 (set-buffer "*Help*")
|
|
|
1558 (goto-char (point-min))
|
|
|
1559 (forward-line 4)
|
|
|
1560 (setq from (point))
|
|
|
1561 (search-forward "Global Bindings:" nil 'move)
|
|
|
1562 (beginning-of-line)
|
|
|
1563 (setq to (point))))
|
|
|
1564 (insert-buffer-substring "*Help*" from to)))
|
|
|
1565
|
|
|
1566 (defun quail-show-kbd-layout ()
|
|
|
1567 "Show keyboard layout with key tops of multilingual characters."
|
|
|
1568 (insert "--- Keyboard layout ---\n")
|
|
|
1569 (let* ((i 0) ch)
|
|
|
1570 (while (< i quail-keyboard-layout-len)
|
|
|
1571 (if (= (% i 30) 0)
|
|
|
1572 (progn
|
|
|
1573 (newline)
|
|
|
1574 (indent-to (/ i 30)))
|
|
|
1575 (if (= (% i 2) 0)
|
|
|
1576 (insert " ")))
|
|
|
1577 (setq ch (aref quail-keyboard-layout i))
|
|
|
1578 (if (= ch ?\ )
|
|
|
1579 (insert ch)
|
|
|
1580 (let* ((map (cdr (assq ch (cdr (quail-map)))))
|
|
|
1581 (translation (and map (quail-get-translation
|
|
165
|
1582 (car map) (char-to-string ch) 1))))
|
|
155
|
1583 (if (integerp translation)
|
|
|
1584 (insert translation)
|
|
|
1585 (if (consp translation)
|
|
|
1586 (insert (aref (cdr translation) (car translation)))
|
|
|
1587 (insert ch)))))
|
|
|
1588 (setq i (1+ i))))
|
|
|
1589 (newline))
|
|
|
1590
|
|
|
1591 (defun quail-translation-help ()
|
|
|
1592 "Show help message while translating in Quail mode."
|
|
|
1593 (interactive)
|
|
|
1594 (let ((package quail-current-package)
|
|
|
1595 (current-key quail-current-key)
|
|
|
1596 (buf (get-buffer-create "*Quail-Help*")))
|
|
|
1597 (save-excursion
|
|
|
1598 (set-buffer buf)
|
|
|
1599 (erase-buffer)
|
|
|
1600 (setq quail-current-package package)
|
|
|
1601 (insert
|
|
|
1602 (format "You are translating the key sequence \"%s\" in Quail mode.\n"
|
|
|
1603 quail-current-key))
|
|
|
1604 (quail-help-insert-keymap-description
|
|
|
1605 (quail-translation-keymap)
|
|
|
1606 "-----------------------
|
|
|
1607 key binding
|
|
|
1608 --- -------\n")
|
|
|
1609 (goto-char (point-min))
|
|
|
1610 (set-buffer-modified-p nil))
|
|
|
1611 (display-buffer buf)))
|
|
|
1612
|
|
|
1613 (defun quail-conversion-help ()
|
|
|
1614 "Show help message while converting in Quail mode."
|
|
|
1615 (interactive)
|
|
|
1616 (let ((package quail-current-package)
|
|
|
1617 (str (buffer-substring (overlay-start quail-conv-overlay)
|
|
|
1618 (overlay-end quail-conv-overlay)))
|
|
|
1619 (buf (get-buffer-create "*Quail-Help*")))
|
|
|
1620 (save-excursion
|
|
|
1621 (set-buffer buf)
|
|
|
1622 (erase-buffer)
|
|
|
1623 (setq quail-current-package package)
|
|
|
1624 (insert
|
|
|
1625 (format "You are converting the string \"%s\" in Quail mode.\n" str))
|
|
|
1626 (quail-help-insert-keymap-description
|
|
|
1627 (quail-conversion-keymap)
|
|
|
1628 "-----------------------
|
|
|
1629 key binding
|
|
|
1630 --- -------\n")
|
|
|
1631 (goto-char (point-min))
|
|
|
1632 (set-buffer-modified-p nil))
|
|
|
1633 (display-buffer buf)))
|
|
|
1634
|
|
|
1635 ;;
|
|
|
1636 (provide 'quail)
|
|
|
1637
|
|
|
1638 ;;; quail.el ends here
|
