|
70
|
1 ;; Quail -- Simple inputting method
|
|
|
2 ;; Copyright (C) 1992 Free Software Foundation, Inc.
|
|
|
3 ;; This file is part of XEmacs.
|
|
|
4
|
|
|
5 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
6 ;; under the terms of the GNU General Public License as published by
|
|
|
7 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
8 ;; any later version.
|
|
|
9
|
|
|
10 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
11 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
12 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
13 ;; General Public License for more details.
|
|
|
14
|
|
|
15 ;; You should have received a copy of the GNU General Public License
|
|
|
16 ;; along with XEmacs; see the file COPYING. If not, write to the Free
|
|
|
17 ;; Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
18
|
|
|
19 ;;; 92.2.12 created for Mule Ver.0.9.0 by K.Handa <handa@etl.go.jp>
|
|
|
20 ;;; long and gory change log deleted.
|
|
|
21
|
|
|
22 ;; Although, EGG is the major inputing method supported by Mule,
|
|
|
23 ;; it's, for the moment, not convenient for inputing Chinese letters.
|
|
|
24 ;; So, I wrote this program as an alternative to EGG to be used
|
|
|
25 ;; until revision of EGG.
|
|
|
26 ;; I modified all translation tables of cxterm/dict/tit of X.V11R5
|
|
|
27 ;; to be used with this system, those are named as quail-*.el.
|
|
|
28 ;; Please load only necessary tables.
|
|
|
29
|
|
|
30 ;; Quail serves as a front end processor for inputing
|
|
|
31 ;; multilingual text from normal ASCII keyboard. By defining a
|
|
|
32 ;; translation table which maps ASCII string to multilingual
|
|
|
33 ;; string, you can input any text from ASCII keyboard.
|
|
|
34
|
|
|
35 (require 'mule)
|
|
138
|
36 (require 'visual-mode)
|
|
70
|
37
|
|
|
38 ;;;###autoload
|
|
|
39 (defconst quail-version "2.2")
|
|
|
40
|
|
|
41 (defvar quail-region-face 'underline)
|
|
|
42 (defvar quail-selection-face 'highlight)
|
|
|
43
|
|
|
44 (defvar quail-self-insert-after-hook nil
|
|
|
45 "Function(s) to call after inserting quail characters.")
|
|
|
46 (defvar quail-last-char nil
|
|
|
47 "A character typed last time in Quail mode.")
|
|
|
48
|
|
|
49 (defvar quail-completion-buf nil)
|
|
|
50 (defvar quail-guidance-buf nil)
|
|
|
51 (defmacro quail-buffer-alive-p (buf)
|
|
|
52 (list 'and (list 'bufferp buf) (list 'buffer-name buf)))
|
|
|
53
|
|
|
54 ;; Buffer local variables
|
|
|
55 (defvar quail-mode nil
|
|
|
56 "Non-nil if using Quail minor mode.")
|
|
|
57 (make-variable-buffer-local 'quail-mode)
|
|
|
58 (defvar quail-sub-mode nil
|
|
|
59 "Non-nil if in sub-mode of Quail minor mode.")
|
|
|
60 (make-variable-buffer-local 'quail-sub-mode)
|
|
|
61 (defvar quail-keep-state nil)
|
|
|
62 (make-variable-buffer-local 'quail-keep-state)
|
|
|
63 (defvar quail-mode-string nil)
|
|
|
64 (make-variable-buffer-local 'quail-mode-string)
|
|
138
|
65 (defvar quail-extent nil
|
|
70
|
66 "Overlay which covers quail zone.")
|
|
138
|
67 (make-variable-buffer-local 'quail-extent)
|
|
70
|
68 (defvar quail-current-key nil
|
|
|
69 "Within Quail mode, a key string typed so far.")
|
|
|
70 (make-variable-buffer-local 'quail-current-key)
|
|
|
71 (defvar quail-current-str nil
|
|
|
72 "Within Quail mode, a string currently translated from quail-current-key.")
|
|
|
73 (make-variable-buffer-local 'quail-current-str)
|
|
|
74 (defvar quail-previous-extra-mode-list nil)
|
|
|
75 (make-variable-buffer-local 'quail-previous-extra-mode-list)
|
|
|
76
|
|
|
77 ;; Quail package
|
|
|
78
|
|
|
79 ;;;###autoload
|
|
|
80 (defvar quail-package-alist nil
|
|
|
81 "Assoc list of quail-packages. Each element is a list of:
|
|
|
82 NAME, PROMPT, MAP, GUIDANCE, DOC, SUB-MODE-MAP, NOLEARN, DETERMINISTIC,
|
|
|
83 TRANSLATE, LAYOUT, OBSOLETE, DECODE-MAP, and EXTRA-MODE-LIST.
|
|
|
84 See the document of `quail-define-package' for more detail.")
|
|
|
85
|
|
|
86 (defmacro quail-package-name () '(car quail-current-package))
|
|
|
87 (defmacro quail-prompt () '(nth 1 quail-current-package))
|
|
|
88 (defmacro quail-map () '(nth 2 quail-current-package))
|
|
|
89 (defmacro quail-guidance () '(nth 3 quail-current-package))
|
|
|
90 (defmacro quail-document () '(nth 4 quail-current-package))
|
|
|
91 (defmacro quail-sub-mode-map () '(nth 5 quail-current-package))
|
|
|
92 (defmacro quail-nolearn () '(nth 6 quail-current-package))
|
|
|
93 (defmacro quail-deterministic () '(nth 7 quail-current-package))
|
|
|
94 (defmacro quail-translate () '(nth 8 quail-current-package))
|
|
|
95 (defmacro quail-layout () '(nth 9 quail-current-package))
|
|
|
96 (defmacro quail-decode-map () '(nth 11 quail-current-package))
|
|
|
97 (defmacro quail-extra-mode-list () '(nth 12 quail-current-package))
|
|
|
98
|
|
|
99 (defalias 'quail-showkey 'quail-guidance)
|
|
|
100 (defalias 'quail-dynamic-list 'quail-guidance)
|
|
|
101 ;;;###autoload(make-obsolete 'quail-showkey 'quail-guidance)
|
|
|
102 ;;;###autoload(make-obsolete 'quail-dynamic-list 'quail-guidance)
|
|
|
103
|
|
|
104 ;;;###autoload
|
|
|
105 (defvar quail-current-package nil "Current quail-pacakge.")
|
|
|
106 ;;;###autoload
|
|
|
107 (make-variable-buffer-local 'quail-current-package)
|
|
|
108
|
|
|
109 (defvar quail-last-package nil "Last quail-pacakge.")
|
|
|
110
|
|
|
111 (defmacro quail-package (name)
|
|
|
112 "Return quail-package named NAME."
|
|
|
113 (list 'assoc name 'quail-package-alist))
|
|
|
114
|
|
|
115 (defun quail-add-package (package)
|
|
|
116 (let ((pac (quail-package (car package))))
|
|
|
117 (if pac
|
|
|
118 (setcdr pac (cdr package))
|
|
|
119 (setq quail-package-alist (cons package quail-package-alist)))))
|
|
|
120
|
|
|
121 ;;;###autoload
|
|
|
122 (defun quail-use-package (name)
|
|
|
123 "Set current quail package to NAME."
|
|
|
124 (setq quail-current-package (quail-package name))
|
|
|
125 (if (null quail-current-package)
|
|
|
126 (error "No such quail-pacakge: %s" name))
|
|
|
127 (if (null (quail-map))
|
|
|
128 (load-library (quail-prompt)))
|
|
|
129 (if (null (string= name (car quail-current-package)))
|
|
|
130 (setq quail-current-package (quail-package name)))
|
|
|
131 (setq-default quail-current-package quail-current-package))
|
|
|
132
|
|
|
133 (defconst quail-mode-map
|
|
|
134 (let ((map (make-keymap)))
|
|
|
135 (substitute-key-definition 'self-insert-command
|
|
|
136 'quail-self-insert-command
|
|
|
137 map global-map)
|
|
|
138 map))
|
|
|
139
|
|
|
140 (or (assq 'quail-mode minor-mode-alist)
|
|
|
141 (setq minor-mode-alist
|
|
|
142 (cons '(quail-mode " Quail") minor-mode-alist)))
|
|
|
143
|
|
|
144 (or (assq 'quail-mode minor-mode-map-alist)
|
|
|
145 (setq minor-mode-map-alist
|
|
|
146 (cons (cons 'quail-mode quail-mode-map) minor-mode-map-alist)))
|
|
|
147
|
|
|
148 (defconst quail-sub-mode-map
|
|
|
149 (let ((map (copy-keymap quail-mode-map))
|
|
|
150 (i ?0))
|
|
|
151 (while (<= i ?9)
|
|
|
152 (define-key map (char-to-string i) 'quail-self-insert-or-index)
|
|
|
153 (setq i (1+ i)))
|
|
|
154 (define-key map "\en" 'quail-next-candidate)
|
|
|
155 (define-key map "\ep" 'quail-prev-candidate)
|
|
|
156 (define-key map "\eN" 'quail-next-candidate-block)
|
|
|
157 (define-key map "\eP" 'quail-prev-candidate-block)
|
|
|
158 (define-key map "\ei" 'quail-completion)
|
|
|
159 (define-key map "\e " 'quail-select-current)
|
|
|
160 (define-key map "\eg" 'quail-cancel-current)
|
|
|
161 (define-key map "\177" 'quail-backward-delete-char)
|
|
|
162 map))
|
|
|
163
|
|
|
164 (defconst quail-sub-mode-rich-bindings
|
|
|
165 '((">" . quail-next-candidate)
|
|
|
166 ("<" . quail-prev-candidate)
|
|
|
167 ("." . quail-next-candidate-block)
|
|
|
168 ("," . quail-prev-candidate-block)
|
|
|
169 (" " . quail-select-current)
|
|
|
170 ))
|
|
|
171
|
|
|
172 (defun quail-define-package (name prompt &optional guidance doc key-bindings
|
|
|
173 nolearn deterministic translate layout
|
|
|
174 obsolete decode-map extra-mode-list)
|
|
|
175 "Define NAME as a quail-package with initial quail map.
|
|
|
176 The second argument PROMPT is a string to be displayed as a name of
|
|
|
177 minor mode when NAME is selected as current package of quail-mode.
|
|
|
178 Optional arguments are GUIDANCE, DOC, KEY-BINDINGS, NOLEARN, DETERMINISTIC,
|
|
|
179 TRANSLATE, LAYOUT, OBSOLETE, DECODE-MAP, EXTRA-MODE-LIST.
|
|
|
180 GUIDANCE is an alist of key and correspoing string to be shown in echo area,
|
|
|
181 t means shows list of candidates,
|
|
|
182 nil means shows typed key.
|
|
|
183 DOC is a document shown by quail-help command.
|
|
|
184 KEY-BINDINGS is an additional key-bindings for control in quail-sub-mode,
|
|
|
185 the value should be a list of cons of KEY and COMMAND.
|
|
|
186 NOLEARN non-nil means not remembering a candidate seleceted last time.
|
|
|
187 DETERMINISTIC non-nil means deterministic translation
|
|
|
188 and NOLEARN is automatically set to t.
|
|
|
189 TRANSLATE non-nil means input characters are mapped to vt100 layout
|
|
|
190 with quail-keyboard-translate-table.
|
|
|
191 LAYOUT non-nil means translated keyboard layout to be displayed by quail-help.
|
|
|
192 OBSOLETE is an obsolete argument, anything specified is ignored.
|
|
|
193 DECODE-MAP non-nil means create decoding map.
|
|
|
194 EXTRA-MODE-LIST is a list of symbols of minor-modes to be set.
|
|
|
195 The current quail-package is set to this package and following quail-defrule
|
|
|
196 defines translation rules in it."
|
|
|
197 (if deterministic (setq nolearn t)) ;92.10.26 by T.Saneto
|
|
|
198 (quail-add-package
|
|
|
199 (list name prompt (make-sparse-keymap) guidance (or doc "") key-bindings
|
|
|
200 nolearn deterministic translate layout nil
|
|
|
201 (if decode-map '(0) nil)
|
|
|
202 extra-mode-list))
|
|
|
203 (quail-use-package name)
|
|
|
204 nil)
|
|
|
205
|
|
|
206 (defconst quail-keyboard-standard-table
|
|
|
207 '("\
|
|
|
208 1234567890-=`\
|
|
|
209 qwertyuiop[]\
|
|
|
210 asdfghjkl;'\\\
|
|
|
211 zxcvbnm,./\
|
|
|
212 !@#$%^&*()_+~\
|
|
|
213 QWERTYUIOP{}\
|
|
|
214 ASDFGHJKL:\"|\
|
|
|
215 ZXCVBNM<>?\
|
|
|
216 "
|
|
|
217 nil))
|
|
|
218
|
|
|
219 (defvar quail-keyboard-translate-table
|
|
|
220 quail-keyboard-standard-table
|
|
|
221 "List of QUAIL-TRANSLATE-TABLE (first element) and QUAIL-ASSOC-TABLE
|
|
|
222 (second element).
|
|
|
223 QUAIL-TRANSLATE-TABLE is a string which represents the 'normalised'
|
|
|
224 layout of a particular keyboard.
|
|
|
225 QUAIL-ASSOC-TABLE is an a-list which describes 'unordinary' key
|
|
|
226 locations. A key location is given by a vector of the form
|
|
|
227 [x-position y-position shift-or-not]. For example, the '1' (one)
|
|
|
228 key's location is [0 0 0], and 'W' (capital letter W) is [1 1 1]. The
|
|
|
229 third element being 0 means unshifted, 1 means shifted. If
|
|
|
230 QUAIL-ASSOC-TABLE is NIL, the first argument given to quail-defrule
|
|
|
231 will not be translated.")
|
|
|
232
|
|
|
233 (defconst quail-keyboard-translate-table-sun-type3
|
|
|
234 '("\
|
|
|
235 1234567890-=\\\
|
|
|
236 qwertyuiop[]\
|
|
|
237 asdfghjkl;'`\
|
|
|
238 zxcvbnm,./\
|
|
|
239 !@#$%^&*()_+|\
|
|
|
240 QWERTYUIOP{}\
|
|
|
241 ASDFGHJKL:\"~\
|
|
|
242 ZXCVBNM<>?\
|
|
|
243 "
|
|
|
244 ((?` [13 0 0]) (?~ [13 0 1]))))
|
|
|
245
|
|
|
246 (defconst quail-keyboard-translate-table-sun-type4
|
|
|
247 '("\
|
|
|
248 1234567890-=\\\
|
|
|
249 qwertyuiop[]\
|
|
|
250 asdfghjkl;'`\
|
|
|
251 zxcvbnm,./\
|
|
|
252 !@#$%^&*()_+|\
|
|
|
253 QWERTYUIOP{}\
|
|
|
254 ASDFGHJKL:\"~\
|
|
|
255 ZXCVBNM<>?\
|
|
|
256 "
|
|
|
257 ((?\\ [11 -1 0]) (?| [11 -1 1]))))
|
|
|
258
|
|
|
259 (defconst quail-keyboard-translate-table-sony-nwp-411a
|
|
|
260 '("\
|
|
|
261 1234567890-=\\\
|
|
|
262 qwertyuiop[]\
|
|
|
263 asdfghjkl;'`\
|
|
|
264 zxcvbnm,./\
|
|
|
265 !@#$%^&*()_+|\
|
|
|
266 QWERTYUIOP{}\
|
|
|
267 ASDFGHJKL:\"~\
|
|
|
268 ZXCVBNM<>?\
|
|
|
269 "
|
|
|
270 nil))
|
|
|
271
|
|
|
272 (defconst quail-keyboard-translate-table-jis
|
|
|
273 '("\
|
|
|
274 1234567890-^\\\
|
|
|
275 qwertyuiop@[\
|
|
|
276 asdfghjkl;:]\
|
|
|
277 zxcvbnm,./\
|
|
|
278 !\"#$%&'()_=`|\
|
|
|
279 QWERTYUIOP~{\
|
|
|
280 ASDFGHJKL+*}\
|
|
|
281 ZXCVBNM<>?\
|
|
|
282 "
|
|
|
283 ((?_ [10 3 1]))))
|
|
|
284
|
|
|
285 (defconst quail-keyboard-translate-table-fujitsu-sigma-230
|
|
|
286 '("\
|
|
|
287 1234567890-^\\\
|
|
|
288 qwertyuiop@[\
|
|
|
289 asdfghjkl;:]\
|
|
|
290 zxcvbnm,./\
|
|
|
291 !\"#$%&'()_=~|\
|
|
|
292 QWERTYUIOP`{\
|
|
|
293 ASDFGHJKL+*}\
|
|
|
294 ZXCVBNM<>?\
|
|
|
295 "
|
|
|
296 ((?_ [10 3 1]))))
|
|
|
297
|
|
|
298 (defconst quail-keyboard-translate-table-ibm-at
|
|
|
299 '("\
|
|
|
300 1234567890-=\\\
|
|
|
301 qwertyuiop[]\
|
|
|
302 asdfghjkl;'`\
|
|
|
303 zxcvbnm,./\
|
|
|
304 !@#$%^&*()_+|\
|
|
|
305 QWERTYUIOP{}\
|
|
|
306 ASDFGHJKL:\"~\
|
|
|
307 ZXCVBNM<>?\
|
|
|
308 "
|
|
|
309 ((?` [-1 0 0]) (?~ [-1 0 1]))))
|
|
|
310
|
|
|
311 (defconst quail-keyboard-translate-table-ibm-rt/pc
|
|
|
312 '("\
|
|
|
313 1234567890-=`\
|
|
|
314 qwertyuiop[]\
|
|
|
315 asdfghjkl;'\\\
|
|
|
316 zxcvbnm,./\
|
|
|
317 !@#$%^&*()_+~\
|
|
|
318 QWERTYUIOP{}\
|
|
|
319 ASDFGHJKL:\"|\
|
|
|
320 ZXCVBNM<>?\
|
|
|
321 "
|
|
|
322 ((?` [-1 0 0]) (?~ [-1 0 1]) (?\\ [12 1 0]) (?| [12 1 1]))))
|
|
|
323
|
|
|
324 (defconst quail-keyboard-translate-table-decstation
|
|
|
325 '("\
|
|
|
326 1234567890-=`\
|
|
|
327 qwertyuiop[]\
|
|
|
328 asdfghjkl;'\\\
|
|
|
329 zxcvbnm,./\
|
|
|
330 !@#$%^&*()_+~\
|
|
|
331 QWERTYUIOP{}\
|
|
|
332 ASDFGHJKL:\"|\
|
|
|
333 ZXCVBNM<>?\
|
|
|
334 "
|
|
|
335 ((?` [-1 3 0]) (?~ [-1 3 1]))))
|
|
|
336
|
|
|
337 (defconst quail-keyboard-translate-table-dynabook
|
|
|
338 '("\
|
|
|
339 1234567890-=`\
|
|
|
340 qwertyuiop[]\
|
|
|
341 asdfghjkl;'\\\
|
|
|
342 zxcvbnm,./\
|
|
|
343 !@#$%^&*()_+~\
|
|
|
344 QWERTYUIOP{}\
|
|
|
345 ASDFGHJKL:\"|\
|
|
|
346 ZXCVBNM<>?\
|
|
|
347 "
|
|
|
348 ((?` [7 4 0]) (?~ [7 4 1]) (?\\ [1 4 0]) (?| [1 4 1]))))
|
|
|
349
|
|
|
350 (defconst quail-keyboard-translate-table-mac-mo110
|
|
|
351 '("\
|
|
|
352 1234567890-=`\
|
|
|
353 qwertyuiop[]\
|
|
|
354 asdfghjkl;'\\\
|
|
|
355 zxcvbnm,./\
|
|
|
356 !@#$%^&*()_+~\
|
|
|
357 QWERTYUIOP{}\
|
|
|
358 ASDFGHJKL:\"|\
|
|
|
359 ZXCVBNM<>?\
|
|
|
360 "
|
|
|
361 ((?` [-1 0 0]) (?~ [-1 0 1]) (?\\ [8 4 0]) (?| [8 4 1]))))
|
|
|
362
|
|
|
363 (defconst quail-keyboard-translate-table-mac-mo116
|
|
|
364 '("\
|
|
|
365 1234567890-=`\
|
|
|
366 qwertyuiop[]\
|
|
|
367 asdfghjkl;'\\\
|
|
|
368 zxcvbnm,./\
|
|
|
369 !@#$%^&*()_+~\
|
|
|
370 QWERTYUIOP{}\
|
|
|
371 ASDFGHJKL:\"|\
|
|
|
372 ZXCVBNM<>?\
|
|
|
373 "
|
|
|
374 ((?` [1 4 0]) (?~ [1 4 1]) (?\\ [7 4 0]) (?| [7 4 1]))))
|
|
|
375
|
|
|
376 (defun quail-defrule (key candidate &optional name)
|
|
|
377 "Define KEY (string) to produce CANDIDATE in the current quail-map.
|
|
|
378 CANDIDATE is a string, a list of strings, a quail-map, a command, or a symbol.
|
|
|
379 If the string contains only one character, the character code (integer) is
|
|
|
380 also acceptable.
|
|
|
381 The command should be a lisp function suitable for interactive
|
|
|
382 calling (and called with no argument).
|
|
|
383 The symbol's function definition should be a quail-map.
|
|
|
384 Optional arg PACKAGE indicates the package name to be used."
|
|
|
385 (let* ((quail-current-package
|
|
|
386 (if name (quail-package name) quail-current-package))
|
|
|
387 (map (quail-map)))
|
|
|
388 (if (not (keymapp map))
|
|
|
389 (error "QUAIL: Invalid quail-map: %s" map)
|
|
|
390 (if (or (keymapp candidate) ; another quail-map
|
|
|
391 (symbolp candidate)) ; command or symbol
|
|
|
392 (define-key map key candidate)
|
|
|
393 (if (integerp candidate)
|
|
|
394 (setq candidate (char-to-string candidate)))
|
|
|
395 (if (and (setq map (lookup-key map key))
|
|
|
396 (keymapp map))
|
|
|
397 (if (vectorp (car (cdr map)))
|
|
|
398 (define-key map "\0" candidate)
|
|
|
399 (setcdr map (cons (vector candidate) (cdr map))))
|
|
|
400 (define-key (quail-map) key (list 'keymap (vector candidate)))))
|
|
|
401 (if (null (vectorp candidate))
|
|
|
402 (let ((decode-map (quail-decode-map))
|
|
|
403 tbl)
|
|
|
404 (if decode-map
|
|
|
405 (if (setq tbl (assoc candidate decode-map))
|
|
|
406 (setcdr tbl key)
|
|
|
407 (setcar (nthcdr 11 quail-current-package)
|
|
|
408 (cons (cons candidate key) decode-map))))))
|
|
|
409 ))
|
|
|
410 nil)
|
|
|
411
|
|
|
412 (defalias 'qd 'quail-defrule)
|
|
|
413 (defmacro qdv (key str) (list 'quail-defrule key (list 'vector str)))
|
|
|
414
|
|
|
415 (defun quail-message (msg)
|
|
|
416 (or (eq (current-buffer) (window-buffer (minibuffer-window)))
|
|
|
417 (message "%s" msg)))
|
|
|
418
|
|
|
419 (defun quail-select-package (name)
|
|
|
420 "Select quail-package."
|
|
|
421 (interactive
|
|
|
422 (let* ((completion-ignore-case t)
|
|
|
423 (default (if quail-last-package
|
|
|
424 (car quail-last-package)))
|
|
|
425 (package-name (completing-read
|
|
|
426 (format "Quail Package (%s): " default)
|
|
|
427 quail-package-alist nil t nil)))
|
|
|
428 (if (> (length package-name) 0) (list package-name) (list default))))
|
|
|
429 (if (quail-package name)
|
|
|
430 (progn
|
|
|
431 (setq quail-last-package quail-current-package)
|
|
|
432 (quail-use-package name)
|
|
|
433 (if quail-mode
|
|
|
434 (progn (quail-exit-mode) (quail-mode))))))
|
|
|
435
|
|
|
436 ;;;###autoload
|
|
|
437 (defun quail-mode (&optional arg)
|
|
|
438 "Toggle Quail minor mode.
|
|
|
439 With arg, turn Quail mode on if and only if arg is positive.
|
|
|
440 The command key you can use in Quail mode depends on a quail package.
|
|
|
441 Try \\[describe-bindings] in quail-mode.
|
|
|
442 The description about the current quail package is shown by \\[quail-help]."
|
|
|
443 (interactive "P")
|
|
|
444 (setq quail-mode (if (null arg)
|
|
|
445 (null quail-mode)
|
|
|
446 (> (prefix-numeric-value arg) 0)))
|
|
|
447 (if quail-mode
|
|
|
448 (if quail-package-alist
|
|
|
449 (quail-enter-mode)
|
|
|
450 (setq quail-mode nil)
|
|
|
451 (error "QUAIL: No quail-package, one should be loaded in advance."))
|
|
|
452 (quail-exit-mode))
|
|
|
453 (force-mode-line-update 'all))
|
|
|
454
|
|
|
455 (defun quail-setup-guidance-buf ()
|
|
|
456 (or (and (bufferp quail-guidance-buf) (buffer-name quail-guidance-buf))
|
|
|
457 (setq quail-guidance-buf
|
|
|
458 (get-buffer-create " *Quail guide for minibuffer*")))
|
|
|
459 (let ((prompt (quail-prompt))
|
|
|
460 (curbuf (current-buffer)))
|
|
|
461 (set-buffer quail-guidance-buf)
|
|
|
462 (if (null (assq 'quail-mode mode-line-format))
|
|
|
463 (setq mode-line-format
|
|
|
464 (cons '(quail-mode (mc-flag ("[" quail-mode-string "]")))
|
|
|
465 mode-line-format)))
|
|
|
466 (setq quail-mode t
|
|
|
467 quail-mode-string prompt)
|
|
|
468 (erase-buffer)
|
|
138
|
469 (or (extentp quail-extent)
|
|
|
470 (setq quail-extent (make-extent 1 1)))
|
|
70
|
471 (set-buffer curbuf))
|
|
|
472 (cond ((get-buffer-window quail-guidance-buf)
|
|
|
473 ;; `buf' is already shown in some window.
|
|
|
474 )
|
|
|
475 ((null (eq (current-buffer) (window-buffer (minibuffer-window))))
|
|
|
476 ;; We are in normal buffer, let's use minibuffer.
|
|
|
477 (set-window-buffer (minibuffer-window) quail-guidance-buf))
|
|
|
478 (t
|
|
|
479 ;; Since we are in minibuffer, we can't use it.
|
|
|
480 ;; Let's find the bottom window.
|
|
|
481 (let ((window-min-height 1)
|
|
|
482 (win (frame-lowest-window (selected-frame)))
|
|
|
483 height)
|
|
|
484 (setq height (window-height win))
|
|
|
485 (if (>= height 4)
|
|
|
486 (setq win (split-window win (- height 2))))
|
|
|
487 (set-window-buffer win quail-guidance-buf)))))
|
|
|
488
|
|
|
489 (defun quail-delete-guidance-buf ()
|
|
|
490 (if (and (bufferp quail-guidance-buf) (buffer-name quail-guidance-buf))
|
|
|
491 (if (eq (current-buffer) (window-buffer (minibuffer-window)))
|
|
|
492 (let ((win (get-buffer-window quail-guidance-buf)))
|
|
|
493 (if win (delete-window win)))
|
|
|
494 (set-window-buffer (minibuffer-window)
|
|
|
495 (format " *Minibuf-%d*" (minibuffer-depth))))))
|
|
|
496
|
|
|
497 (defun quail-enter-mode ()
|
|
|
498 (or (eq (car (car minor-mode-map-alist)) 'quail-mode)
|
|
|
499 (setq minor-mode-map-alist
|
|
|
500 (cons (cons 'quail-mode quail-mode-map) minor-mode-map-alist)))
|
|
|
501 (quail-use-package (or (car quail-current-package)
|
|
|
502 (car (car quail-package-alist))))
|
|
|
503 (setq quail-mode-string (quail-prompt))
|
|
|
504 (if (null (assq 'quail-mode mode-line-format))
|
|
|
505 (setq mode-line-format
|
|
|
506 (cons '(quail-mode (mc-flag ("[" quail-mode-string "]")))
|
|
|
507 mode-line-format)))
|
|
138
|
508 (if (null (extentp quail-extent))
|
|
70
|
509 (progn
|
|
138
|
510 (setq quail-extent (make-extent (point) (point)))
|
|
|
511 (set-extent-face quail-extent 'face quail-region-face)))
|
|
70
|
512 (make-local-hook 'post-command-hook)
|
|
|
513 (add-hook 'post-command-hook 'quail-reset-state nil t)
|
|
|
514 (setq quail-keep-state nil)
|
|
|
515 (if (quail-sub-mode-map)
|
|
|
516 (progn
|
|
|
517 (if (null (keymapp (quail-sub-mode-map)))
|
|
|
518 (let ((bindings (quail-sub-mode-map))
|
|
|
519 (map (copy-keymap quail-sub-mode-map)))
|
|
|
520 (while bindings
|
|
|
521 (define-key map (car (car bindings)) (cdr (car bindings)))
|
|
|
522 (setq bindings (cdr bindings)))
|
|
|
523 (setcar (nthcdr 5 quail-current-package) map)))))
|
|
|
524 (let ((modes (quail-extra-mode-list))
|
|
|
525 (i 0))
|
|
|
526 (setq quail-previous-extra-mode-list (make-list (length modes) nil))
|
|
|
527 (while modes
|
|
|
528 (setcar (nthcdr i quail-previous-extra-mode-list)
|
|
|
529 (symbol-value (car modes)))
|
|
|
530 (if (null (symbol-value (car modes)))
|
|
|
531 (funcall (car modes) 1))
|
|
|
532 (setq i (1+ i) modes (cdr modes))))
|
|
|
533 (quail-init-state)
|
|
|
534 (quail-message (substitute-command-keys "\\[quail-help] for help."))
|
|
|
535 (run-hooks 'quail-mode-hook))
|
|
|
536
|
|
|
537 (defun quail-exit-mode ()
|
|
|
538 (interactive)
|
|
|
539 (kill-local-variable 'post-command-hook)
|
|
138
|
540 (delete-extent quail-extent)
|
|
70
|
541 (quail-delete-guidance-buf)
|
|
|
542 (let ((modes (quail-extra-mode-list))
|
|
|
543 (i 0))
|
|
|
544 (while modes
|
|
|
545 (if (null (nth i quail-previous-extra-mode-list))
|
|
|
546 (funcall (car modes) -1))
|
|
|
547 (setq i (1+ i) modes (cdr modes))))
|
|
|
548 (setq quail-mode nil))
|
|
|
549
|
|
|
550 (defun quail-enter-sub-mode ()
|
|
|
551 (setcdr (assoc 'quail-mode minor-mode-map-alist)
|
|
|
552 (or (quail-sub-mode-map) quail-sub-mode-map))
|
|
|
553 (setq quail-sub-mode t))
|
|
|
554
|
|
|
555 (defun quail-exit-sub-mode ()
|
|
|
556 (setcdr (assoc 'quail-mode minor-mode-map-alist) quail-mode-map)
|
|
|
557 (setq quail-sub-mode nil))
|
|
|
558
|
|
|
559 (defun quail-reset-state ()
|
|
|
560 (if quail-mode
|
|
|
561 (if quail-keep-state
|
|
|
562 (setq quail-keep-state nil)
|
|
|
563 (quail-init-state))))
|
|
|
564
|
|
|
565 (defun quail-init-state ()
|
|
138
|
566 (if (extentp quail-extent)
|
|
|
567 (set-extent-endpoints quail-extent (point) (point))
|
|
|
568 (setq quail-extent (make-extent (point) (point))))
|
|
70
|
569 (setq quail-current-key nil
|
|
|
570 quail-current-str nil)
|
|
|
571 (if quail-sub-mode (quail-exit-sub-mode))
|
|
|
572 (quail-setup-guidance-buf))
|
|
|
573
|
|
|
574 (defun quail-check-state ()
|
|
138
|
575 (if (and (extent-object quail-extent)
|
|
|
576 (= (point) (extent-end-position quail-extent)))
|
|
70
|
577 quail-current-key
|
|
|
578 (quail-init-state)
|
|
|
579 nil))
|
|
|
580
|
|
|
581 (defun quail-delete-region ()
|
|
138
|
582 (delete-region (extent-start-position quail-extent) (extent-end-position quail-extent)))
|
|
70
|
583
|
|
|
584 (defun quail-insert (str)
|
|
|
585 (quail-delete-region)
|
|
|
586 (if visual-mode
|
|
|
587 (if (stringp str)
|
|
|
588 (let ((l (string-to-char-list str))) ;93.4.30 by Takahashi N.
|
|
|
589 (while l
|
|
|
590 (visual-insert-1-char (car l))
|
|
|
591 (setq l (cdr l))))
|
|
|
592 (visual-insert-1-char str))
|
|
|
593 (insert str))
|
|
|
594 (if (and auto-fill-function (> (current-column) fill-column))
|
|
|
595 (run-hooks 'auto-fill-function))
|
|
|
596 (let ((len (if (integerp str) (char-bytes str) (length str))))
|
|
138
|
597 (set-extent-endpoints quail-extent (- (point) len) (point)))
|
|
70
|
598 (quail-show-guidance))
|
|
|
599
|
|
|
600 (defun quail-get-candidates (def)
|
|
|
601 (setq def (car (cdr def)))
|
|
|
602 (if (null (vectorp def))
|
|
|
603 nil
|
|
|
604 (let ((candidates (aref def 0)))
|
|
|
605 (if (vectorp candidates)
|
|
|
606 (progn
|
|
|
607 (setq candidates
|
|
|
608 (cons 0 (string-to-char-list (aref candidates 0))))
|
|
|
609 (aset def 0 candidates))
|
|
|
610 (if (and (listp candidates)
|
|
|
611 (stringp (car candidates)))
|
|
|
612 (progn
|
|
|
613 (setq candidates (cons 0 candidates))
|
|
|
614 (aset def 0 candidates))))
|
|
|
615 candidates)))
|
|
|
616
|
|
|
617 (defun quail-get-candidate (def &optional nolearn)
|
|
|
618 (let ((candidates (quail-get-candidates def)))
|
|
|
619 (if candidates
|
|
|
620 (if (not (listp candidates)) ;93.1.17 by K.Handa
|
|
|
621 (if (integerp candidates)
|
|
|
622 candidates
|
|
|
623 (if (and (symbolp candidates) (fboundp candidates))
|
|
|
624 (if (keymapp (symbol-function candidates))
|
|
|
625 (symbol-function candidates)
|
|
|
626 (funcall candidates))
|
|
|
627 candidates))
|
|
|
628 (if nolearn
|
|
|
629 (rplaca candidates 0))
|
|
|
630 (nth (car candidates) (cdr candidates)))))) ;93.1.17 by K.Handa
|
|
|
631
|
|
|
632 (defun quail-show-guidance ()
|
|
|
633 ;; At first, show dynamic list or current keyin string in echo area.
|
|
|
634 (quail-setup-guidance-buf)
|
|
|
635 (let ((guidance (quail-guidance)))
|
|
|
636 (if (eq guidance t)
|
|
|
637 (quail-list-dynamically)
|
|
|
638 (save-excursion
|
|
|
639 (let ((key quail-current-key))
|
|
|
640 (save-excursion
|
|
|
641 (set-buffer quail-guidance-buf)
|
|
|
642 (if (null guidance)
|
|
|
643 (insert key)
|
|
|
644 (let ((i 0) (len (length key)) ch show)
|
|
|
645 (while (< i len)
|
|
|
646 (setq ch (aref key i))
|
|
|
647 (setq show (cdr (assoc ch guidance)))
|
|
|
648 (insert (if show show (char-to-string ch)))
|
|
|
649 (setq i (1+ i))))))))))
|
|
|
650 ;; Then highlight the current candidate string in *Completion* buffer if any.
|
|
|
651 (if (and (quail-buffer-alive-p quail-completion-buf)
|
|
|
652 (get-buffer-window quail-completion-buf))
|
|
|
653 (let ((buf (current-buffer))
|
|
|
654 (str (if (stringp quail-current-str)
|
|
|
655 quail-current-str
|
|
|
656 (if (numberp quail-current-str)
|
|
|
657 (char-to-string quail-current-str))))
|
|
|
658 (key quail-current-key))
|
|
|
659 (select-window (get-buffer-window quail-completion-buf))
|
|
|
660 (goto-char (point-min))
|
|
|
661 (if (search-forward (concat " " key ":") nil t)
|
|
|
662 (if (and str (search-forward (concat "." str) nil t))
|
|
138
|
663 (set-extent-endpoints quail-extent (1+ (match-beginning 0)) (point))
|
|
|
664 (set-extent-endpoints quail-extent (match-beginning 0) (point)))
|
|
|
665 (set-extent-endpoints quail-extent 1 1))
|
|
70
|
666 (select-window (get-buffer-window buf))
|
|
|
667 )))
|
|
|
668
|
|
|
669 (defun quail-translate-char (ch)
|
|
|
670 (let* ((str (car quail-keyboard-translate-table))
|
|
|
671 (len (length str))
|
|
|
672 (i 0))
|
|
|
673 (while (and (< i len) (/= ch (aref str i)))
|
|
|
674 (setq i (1+ i)))
|
|
|
675 (if (= i len)
|
|
|
676 (error "'%c' not found in quail-keyboard-translate-table" ch))
|
|
|
677 (aref (car quail-keyboard-standard-table) i)))
|
|
|
678
|
|
|
679 (defun quail-select-current ()
|
|
|
680 "Select the current candidate."
|
|
|
681 (interactive "*")
|
|
|
682 (quail-self-insert-command t))
|
|
|
683
|
|
|
684 (defun quail-self-insert-or-index ()
|
|
|
685 "Select a character from the current 10 candidates by digit."
|
|
|
686 (interactive "*")
|
|
|
687 (quail-self-insert-command (- last-command-char ?0)))
|
|
|
688
|
|
|
689 (defun quail-lookup-key (key)
|
|
|
690 (let ((def (lookup-key (quail-map) key)))
|
|
|
691 (if (and (symbolp def) (fboundp def))
|
|
|
692 (setq def (symbol-function def)))
|
|
|
693 def))
|
|
|
694
|
|
|
695 (defun quail-self-insert-command (&optional arg)
|
|
|
696 (interactive "*")
|
|
|
697 (setq quail-keep-state t)
|
|
|
698 (quail-check-state)
|
|
|
699 (setq quail-last-char last-command-char)
|
|
|
700 (let* ((ch (if (quail-translate)
|
|
|
701 (quail-translate-char quail-last-char)
|
|
|
702 quail-last-char))
|
|
|
703 (chstr (char-to-string ch))
|
|
|
704 (key (if quail-current-key
|
|
|
705 (format "%s%c" quail-current-key ch)
|
|
|
706 chstr))
|
|
|
707 (def (quail-lookup-key key)))
|
|
|
708 (cond ((keymapp def)
|
|
|
709 (setq quail-current-key key)
|
|
|
710 (setq quail-current-str (quail-get-candidate def (quail-nolearn)))
|
|
|
711 (quail-insert (or quail-current-str quail-current-key))
|
|
|
712 (if (and quail-current-str
|
|
|
713 (null (nthcdr 2 def))
|
|
|
714 (setq def (aref (nth 1 def) 0))
|
|
|
715 (or (null (listp def)) (= (length def) 2))
|
|
|
716 (null (and (>= (length quail-current-key) 3)
|
|
|
717 (lookup-key (quail-map) chstr))))
|
|
|
718 (quail-init-state)))
|
|
|
719 ((commandp def)
|
|
|
720 (setq quail-current-key key)
|
|
|
721 (if (keymapp (symbol-function def))
|
|
|
722 (progn
|
|
|
723 (setq quail-current-str nil)
|
|
|
724 (quail-insert quail-current-key))
|
|
|
725 (call-interactively def)))
|
|
|
726 ((and (numberp arg) quail-current-str (null (quail-deterministic)))
|
|
|
727 (quail-indexed-candidate arg))
|
|
|
728 ((eq arg t)
|
|
|
729 (quail-init-state))
|
|
|
730 (quail-current-key
|
|
|
731 (let ((len (length key)) str)
|
|
|
732 (if (and (>= len 4)
|
|
|
733 (keymapp (lookup-key (quail-map) (substring key -2)))
|
|
|
734 (setq def (quail-lookup-key (substring key 0 -2)))
|
|
|
735 (keymapp def)
|
|
|
736 (setq str (quail-get-candidate def (quail-nolearn))))
|
|
|
737 (progn
|
|
|
738 (quail-delete-region)
|
|
|
739 (insert str)
|
|
|
740 (quail-init-state)
|
|
|
741 (setq unread-command-events
|
|
|
742 (cons (aref key (- len 2))
|
|
|
743 (cons ch unread-command-events))))
|
|
|
744 (quail-init-state)
|
|
|
745 (quail-self-insert-command))))
|
|
|
746 (t
|
|
|
747 (quail-init-state)
|
|
|
748 (self-insert-command 1)))
|
|
|
749 (run-hooks 'quail-self-insert-after-hook)
|
|
|
750 )
|
|
|
751 (if (and quail-current-key (null quail-sub-mode))
|
|
|
752 (quail-enter-sub-mode))
|
|
|
753 )
|
|
|
754
|
|
138
|
755 ;; wire us into pending-delete
|
|
|
756 (put 'quail-self-insert-command 'pending-delete t)
|
|
|
757
|
|
70
|
758 (defun quail-next-candidate ()
|
|
|
759 "Select next candidate."
|
|
|
760 (interactive)
|
|
|
761 (setq quail-keep-state t)
|
|
|
762 (if (and (quail-check-state) quail-current-str)
|
|
|
763 (quail-select-candidate 1 t)
|
|
|
764 (beep)))
|
|
|
765
|
|
|
766 (defun quail-prev-candidate ()
|
|
|
767 "Select previous candidate."
|
|
|
768 (interactive)
|
|
|
769 (setq quail-keep-state t)
|
|
|
770 (if (and (quail-check-state) quail-current-str)
|
|
|
771 (quail-select-candidate -1 t)
|
|
|
772 (beep)))
|
|
|
773
|
|
|
774 (defun quail-indexed-candidate (idx)
|
|
|
775 (setq idx (if (= idx 0) 9 (1- idx)))
|
|
|
776 (quail-select-candidate idx nil t)
|
|
|
777 (quail-init-state))
|
|
|
778
|
|
|
779 (defun quail-next-candidate-block ()
|
|
|
780 "Select candidate in next 10 alternatives."
|
|
|
781 (interactive)
|
|
|
782 (setq quail-keep-state t)
|
|
|
783 (if (and (quail-check-state) quail-current-str)
|
|
|
784 (quail-select-candidate 10 t t)
|
|
|
785 (beep)))
|
|
|
786
|
|
|
787 (defun quail-prev-candidate-block ()
|
|
|
788 "Select candidate in previous 10 alternatives."
|
|
|
789 (interactive)
|
|
|
790 (setq quail-keep-state t)
|
|
|
791 (if (and (quail-check-state) quail-current-str)
|
|
|
792 (quail-select-candidate -10 t t)
|
|
|
793 (beep)))
|
|
|
794
|
|
|
795 (defun quail-select-candidate (idx &optional relative block)
|
|
|
796 (let* ((def (quail-lookup-key quail-current-key))
|
|
|
797 (candidates (quail-get-candidates def)))
|
|
|
798 (if (listp candidates)
|
|
|
799 (let ((maxidx (- (length candidates) 2))
|
|
|
800 (current-idx (car candidates)))
|
|
|
801 (if relative
|
|
|
802 (setq idx (+ current-idx idx))
|
|
|
803 (if block
|
|
|
804 (setq idx (+ (* (/ current-idx 10) 10) idx))))
|
|
|
805 (if block
|
|
|
806 (if (> idx maxidx)
|
|
|
807 (if (/= (/ maxidx 10) (/ current-idx 10))
|
|
|
808 (setq idx maxidx)
|
|
|
809 (beep)
|
|
|
810 (setq idx current-idx))
|
|
|
811 (if (< idx 0) (progn (beep) (setq idx (+ idx 10)))))
|
|
|
812 (if (> idx maxidx) (setq idx 0)
|
|
|
813 (if (< idx 0) (setq idx maxidx))))
|
|
|
814 (rplaca candidates idx)
|
|
|
815 (setq quail-current-str (nth (car candidates) (cdr candidates)))
|
|
|
816 (quail-insert quail-current-str)))))
|
|
|
817
|
|
|
818 (defun quail-cancel-current ()
|
|
|
819 "Cancel the current key sequence."
|
|
|
820 (interactive)
|
|
|
821 (quail-delete-region)
|
|
|
822 (quail-init-state))
|
|
|
823
|
|
|
824 (defun quail-backward-delete-char (arg)
|
|
|
825 "Delete characters backward in quail-mode."
|
|
|
826 (interactive "*p")
|
|
|
827 (if (= (length quail-current-key) 1)
|
|
|
828 (progn
|
|
|
829 (quail-delete-region)
|
|
|
830 (quail-init-state))
|
|
|
831 (setq quail-keep-state t)
|
|
|
832 (setq quail-current-key (substring quail-current-key 0 -1))
|
|
|
833 (let ((def (quail-lookup-key quail-current-key)))
|
|
|
834 (setq quail-last-char
|
|
|
835 (aref quail-current-key (1- (length quail-current-key))))
|
|
|
836 (setq quail-current-str
|
|
|
837 (quail-get-candidate def (quail-nolearn))) ;93.1.17 by K.Handa
|
|
|
838 (quail-insert (or quail-current-str quail-current-key)))))
|
|
|
839
|
|
|
840 (defvar quail-work-str (make-string 128 0))
|
|
|
841
|
|
|
842 (defun quail-list-dynamically ()
|
|
|
843 "Show list of candidates dynamically."
|
|
|
844 (let* ((def (quail-lookup-key quail-current-key))
|
|
|
845 (candidates (quail-get-candidates def))
|
|
|
846 (key quail-current-key))
|
|
|
847 (save-excursion
|
|
|
848 (set-buffer quail-guidance-buf)
|
|
|
849 (erase-buffer)
|
|
|
850 (insert key)
|
|
|
851 (if (or (nthcdr 2 def) (listp (car (cdr def))))
|
|
|
852 (let ((i ? ) (l (cdr def)))
|
|
|
853 (while (< i 127) (aset quail-work-str i 0) (setq i (1+ i)))
|
|
|
854 (while l
|
|
|
855 (if (listp (car l))
|
|
|
856 (aset quail-work-str (car (car l)) 1))
|
|
|
857 (setq l (cdr l)))
|
|
|
858 (insert "[")
|
|
|
859 (setq i ? )
|
|
|
860 (while (< i 127)
|
|
|
861 (if (= (aref quail-work-str i) 1)
|
|
|
862 (insert i))
|
|
|
863 (setq i (1+ i)))
|
|
|
864 (insert "]")))
|
|
|
865 (if (consp candidates)
|
|
|
866 (let ((idx (car candidates))
|
|
|
867 (maxidx (1+ (/ (1- (length (cdr candidates))) 10)))
|
|
|
868 (num 0)
|
|
138
|
869 p p1 p2)
|
|
70
|
870 (indent-to 10)
|
|
|
871 (insert (format "(%d/%d)" (1+ (/ idx 10)) maxidx))
|
|
|
872 (setq candidates (nthcdr (* (/ idx 10) 10) (cdr candidates)))
|
|
|
873 (while (and candidates (< num 10))
|
|
|
874 (setq num (1+ num))
|
|
|
875 (insert (format " %d." (if (< num 10) num 0)))
|
|
|
876 (setq p (point))
|
|
|
877 (insert (car candidates))
|
|
|
878 (if (= num (1+ (% idx 10)))
|
|
|
879 (setq p1 p p2 (point)))
|
|
|
880 (setq candidates (cdr candidates)))
|
|
|
881 (put-text-property p1 p2 'face quail-selection-face))))
|
|
|
882 ))
|
|
|
883
|
|
|
884 (defun quail-display-buffer (buf)
|
|
|
885 (if (get-buffer-window buf)
|
|
|
886 nil
|
|
|
887 (let ((curwin (selected-window))
|
|
|
888 (height 0)
|
|
|
889 largest)
|
|
|
890 (walk-windows '(lambda (win)
|
|
|
891 (if (and (null (eq curwin win ))
|
|
|
892 (> (window-height win) height))
|
|
|
893 (setq height (window-height win)
|
|
|
894 largest win))))
|
|
|
895 (set-window-buffer (if (> height (/ (window-height curwin) 2))
|
|
|
896 largest
|
|
|
897 (split-window curwin))
|
|
|
898 buf)
|
|
|
899 )))
|
|
|
900
|
|
|
901 (defun quail-completion ()
|
|
|
902 "Show list of candidates."
|
|
|
903 (interactive)
|
|
|
904 (let ((def (quail-lookup-key quail-current-key))
|
|
|
905 (key quail-current-key))
|
|
|
906 (if (not (keymapp def))
|
|
|
907 (quail-message "No macth.")
|
|
|
908 (setq quail-keep-state t)
|
|
|
909 (save-excursion
|
|
|
910 (if (not (quail-buffer-alive-p quail-completion-buf))
|
|
|
911 (setq quail-completion-buf
|
|
|
912 (get-buffer-create "*Completions*")))
|
|
|
913 (set-buffer quail-completion-buf)
|
|
|
914 (erase-buffer)
|
|
138
|
915 (setq quail-extent (make-extent 1 1))
|
|
|
916 (set-extent-face quail-extent 'face quail-selection-face)
|
|
70
|
917 (insert "Current candidates:\n")
|
|
|
918 (quail-completion-list key def 1)
|
|
|
919 (quail-display-buffer (current-buffer)))
|
|
|
920 (quail-show-guidance))))
|
|
|
921
|
|
|
922 (defun quail-completion-list (key def indent)
|
|
|
923 (let ((candidates (quail-get-candidates def)))
|
|
|
924 (indent-to indent)
|
|
|
925 (insert key ":")
|
|
|
926 (if candidates
|
|
|
927 (quail-candidate-with-indent
|
|
|
928 (if (consp candidates) (cdr candidates) candidates)
|
|
|
929 key)
|
|
|
930 (insert " none\n"))
|
|
|
931 (setq indent (+ indent 2))
|
|
|
932 (setq def (cdr def))
|
|
|
933 (while def
|
|
|
934 (if (listp (vectorp (car def)))
|
|
|
935 (let ((map (cdr (car def))))
|
|
|
936 (if (symbolp map) (setq map (symbol-function map)))
|
|
|
937 (quail-completion-list (format "%s%c" key (car (car def)))
|
|
|
938 map indent)))
|
|
|
939 (setq def (cdr def)))))
|
|
|
940
|
|
|
941 (defun quail-candidate-with-indent (candidates key)
|
|
|
942 (if (consp candidates)
|
|
|
943 (let ((clm (current-column))
|
|
138
|
944 (i 0))
|
|
70
|
945 (while candidates
|
|
|
946 (if (= (% i 10) 0) (insert (format "(%d)" (1+ (/ i 10)))))
|
|
|
947 (insert " " (if (= (% i 10) 9) "0" (+ ?1 (% i 10))) ".")
|
|
|
948 (insert (if (stringp (car candidates))
|
|
|
949 (car candidates)
|
|
|
950 (char-to-string (car candidates))))
|
|
|
951 (setq i (1+ i))
|
|
|
952 (setq candidates (cdr candidates))
|
|
|
953 (if (and candidates (= (% i 10) 0))
|
|
|
954 (progn
|
|
|
955 (insert ?\n)
|
|
|
956 (indent-to clm)))))
|
|
|
957 (if (and (symbolp candidates) (fboundp candidates))
|
|
|
958 (insert " (1) 0."
|
|
|
959 (let ((quail-current-key key)) (funcall candidates)))
|
|
|
960 (insert " (1) 0." candidates)))
|
|
|
961 (insert ?\n))
|
|
|
962
|
|
|
963 (defun quail-help ()
|
|
|
964 "Show brief description of the current quail-pacakge."
|
|
|
965 (interactive)
|
|
|
966 (setq quail-keep-state t)
|
|
|
967 (let ((package quail-current-package)
|
|
|
968 (buf (get-buffer "*Quail-Help*"))
|
|
|
969 (first t))
|
|
|
970 (save-excursion
|
|
|
971 (set-buffer (or buf (get-buffer-create "*Quail-Help*")))
|
|
|
972 (if (and buf (eq package quail-current-package))
|
|
|
973 (setq first nil)
|
|
|
974 (setq buf (current-buffer))
|
|
|
975 (setq quail-current-package package)
|
|
|
976 (erase-buffer)
|
|
|
977 (insert (quail-document))
|
|
|
978 (if (quail-layout) (quail-show-layout))
|
|
|
979 (insert "\n--- Key bindinds ---\n")
|
|
|
980 (let ((map (or (quail-sub-mode-map) quail-sub-mode-map))
|
|
|
981 (i 0))
|
|
|
982 (while (< i 256)
|
|
|
983 (quail-describe-binding map i)
|
|
|
984 (setq i (1+ i)))
|
|
|
985 (setq map (lookup-key map (vector meta-prefix-char)))
|
|
|
986 (setq i 0)
|
|
|
987 (while (< i 256)
|
|
|
988 (quail-describe-binding map i 'meta)
|
|
|
989 (setq i (1+ i)))
|
|
|
990 (goto-char (point-min)))))
|
|
|
991 (let ((win (get-buffer-window buf)))
|
|
|
992 (if win
|
|
|
993 (save-excursion
|
|
|
994 (set-buffer buf)
|
|
|
995 (if (null first)
|
|
|
996 (if (> (point-max) (window-end win))
|
|
|
997 (set-window-start win (window-end win))
|
|
|
998 (if (< (point-min) (window-start win))
|
|
|
999 (set-window-start win 1)))))
|
|
|
1000 (quail-display-buffer buf))
|
|
|
1001 (let (up down)
|
|
|
1002 (save-excursion
|
|
|
1003 (sit-for 0)
|
|
|
1004 (set-buffer buf)
|
|
|
1005 (if (> (point-max) (window-end win))
|
|
|
1006 (setq up t)
|
|
|
1007 (if (< (point-min) (window-start win))
|
|
|
1008 (setq down t))))
|
|
|
1009 (if up
|
|
|
1010 (quail-message
|
|
|
1011 (substitute-command-keys
|
|
|
1012 "\\[quail-help] to scroll up *Quail-Help* buffer."))
|
|
|
1013 (if down
|
|
|
1014 (quail-message
|
|
|
1015 (substitute-command-keys
|
|
|
1016 "\\[quail-help] to show top of *Quail-Help* buffer."))))))
|
|
|
1017 ))
|
|
|
1018
|
|
|
1019 (defun quail-show-layout ()
|
|
|
1020 (let* ((xoff 10)
|
|
|
1021 (yoff 3)
|
|
|
1022 (space 4)
|
|
|
1023 (p (point))
|
|
|
1024 (i 0)
|
|
|
1025 (str (car quail-keyboard-translate-table))
|
|
|
1026 (len (length str))
|
|
|
1027 (alist (car (cdr quail-keyboard-translate-table)))
|
|
|
1028 pos x y ch ch1 kmp)
|
|
|
1029 (insert "
|
|
|
1030
|
|
|
1031
|
|
|
1032
|
|
|
1033
|
|
|
1034
|
|
|
1035
|
|
|
1036
|
|
|
1037
|
|
|
1038 ")
|
|
|
1039 (save-excursion
|
|
|
1040 (while (< i len)
|
|
|
1041 (goto-char p)
|
|
|
1042 (setq ch (aref str i))
|
|
|
1043 (if (setq pos (car (cdr (assoc ch alist))))
|
|
|
1044 (progn (forward-line (+ yoff (aref pos 1)))
|
|
|
1045 (forward-char (+ xoff (* space (aref pos 0))
|
|
|
1046 (aref pos 1) (aref pos 2))))
|
|
|
1047 (cond
|
|
|
1048 ((< i 13) (setq x i y 0)) ; unshifted, 1st row
|
|
|
1049 ((< i 25) (setq x (- i 13) y 1)) ; unshifted, 2nd row
|
|
|
1050 ((< i 37) (setq x (- i 25) y 2)) ; unshifted, 3rd row
|
|
|
1051 ((< i 47) (setq x (- i 37) y 3)) ; unshifted, 4th row
|
|
|
1052 ((< i 60) (setq x (- i 47) y 0)) ; shifted, 1st row
|
|
|
1053 ((< i 72) (setq x (- i 60) y 1)) ; shifted, 2nd row
|
|
|
1054 ((< i 84) (setq x (- i 72) y 2)) ; shifted, 3rd row
|
|
|
1055 ((< i 94) (setq x (- i 84) y 3)) ; shifted, 4th row
|
|
|
1056 (t (setq x (- i 90) y 4))) ; space, bottom row
|
|
|
1057 (forward-line (+ yoff y))
|
|
|
1058 (forward-char (+ xoff (* space x) y (if (< i 47) 0 1))))
|
|
|
1059 (delete-char 1)
|
|
|
1060 (if (quail-translate)
|
|
|
1061 (setq ch (quail-translate-char ch)))
|
|
|
1062 (setq ch1
|
|
|
1063 (and (setq kmp (quail-lookup-key (char-to-string ch)))
|
|
|
1064 (quail-get-candidate kmp (quail-nolearn))))
|
|
|
1065 (insert (if ch1 ch1 ch))
|
|
|
1066 (setq i (1+ i))))))
|
|
|
1067
|
|
|
1068 (defun quail-describe-binding (map i &optional meta)
|
|
|
1069 (let ((cmd (lookup-key map (vector i))))
|
|
|
1070 (if (and (symbolp cmd) (fboundp cmd)
|
|
|
1071 (not (memq cmd '(quail-self-insert-command
|
|
|
1072 quail-self-insert-or-index))))
|
|
|
1073 (progn
|
|
|
1074 (if meta (insert "ESC "))
|
|
|
1075 (insert (single-key-description i) ":")
|
|
|
1076 (indent-to-column 8)
|
|
|
1077 (insert (documentation cmd) "\n")))))
|
|
|
1078
|
|
|
1079 ;;;###autoload
|
|
|
1080 (global-set-key "\C-]" 'quail-mode)
|
|
|
1081
|
|
|
1082 (define-key mule-keymap "M" 'quail-select-package)
|
|
|
1083
|
|
|
1084 ;; For byte-compiler
|
|
|
1085 (put 'quail-defrule 'byte-hunk-handler 'eval)
|
|
|
1086 (put 'qdv 'byte-hunk-handler 'eval)
|
|
|
1087 (put 'qd 'byte-hunk-handler 'eval)
|
|
|
1088 (put 'quail-define-package 'byte-hunk-handler 'eval)
|
|
|
1089
|
|
|
1090 (defun quail-setup-current-package ()
|
|
|
1091 ;; Do nothing while loading non-compiled file.
|
|
|
1092 )
|
|
|
1093
|
|
|
1094 (defun quail-setup-current-package-handler (ignore)
|
|
|
1095 (list 'quail-add-package (list 'quote quail-current-package)))
|
|
|
1096
|
|
|
1097 (put 'quail-setup-current-package 'byte-hunk-handler
|
|
|
1098 'quail-setup-current-package-handler)
|
|
|
1099
|
|
|
1100 ;;
|
|
|
1101 (provide 'quail)
|
