|
70
|
1 ;;; canna.el --- Interface to the Canna input method.
|
|
|
2
|
|
120
|
3 ;; Copyright (C) 1994 Akira Kon, NEC Corporation.
|
|
|
4 ;; Copyright (C) 1996,1997 MORIOKA Tomohiko
|
|
|
5
|
|
|
6 ;; Author: Akira Kon <kon@d1.bs2.mt.nec.co.jp>
|
|
|
7 ;; MORIOKA Tomohiko <morioka@jaist.ac.jp>
|
|
219
|
8 ;; Version: $Revision: 1.9 $
|
|
120
|
9 ;; Keywords: Canna, Japanese, input method, mule, multilingual
|
|
70
|
10
|
|
120
|
11 ;; This file is not a part of Emacs yet.
|
|
70
|
12
|
|
120
|
13 ;; This program is free software; you can redistribute it and/or
|
|
|
14 ;; modify it under the terms of the GNU General Public License as
|
|
|
15 ;; published by the Free Software Foundation; either version 2, or (at
|
|
|
16 ;; your option) any later version.
|
|
|
17
|
|
|
18 ;; This program is distributed in the hope that it will be useful, but
|
|
70
|
19 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
21 ;; General Public License for more details.
|
|
|
22
|
|
|
23 ;; You should have received a copy of the GNU General Public License
|
|
120
|
24 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
70
|
25 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
26 ;; Boston, MA 02111-1307, USA.
|
|
|
27
|
|
120
|
28 ;;; Commentary:
|
|
118
|
29
|
|
120
|
30 ;; Egg offered some influences to the implementation of Canna on
|
|
|
31 ;; Nemacs/Mule, and this file contains a few part of Egg which is
|
|
|
32 ;; written by S.Tomura, Electrotechnical Lab. (tomura@etl.go.jp)
|
|
116
|
33
|
|
120
|
34 ;; This program is rewritten for Emacs/mule and XEmacs/mule by MORIOKA
|
|
|
35 ;; Tomohiko.
|
|
70
|
36
|
|
120
|
37 ;;; Code:
|
|
70
|
38
|
|
|
39 ;; -*-mode: emacs-lisp-*-
|
|
|
40
|
|
120
|
41 ;; by $B<i2,(B $BCNI'(B <morioka@jaist.ac.jp> 1996/11/11
|
|
|
42 (or (boundp 'CANNA)
|
|
163
|
43 (not (fboundp 'dynamic-link))
|
|
120
|
44 (let ((handle (dynamic-link (expand-file-name "canna.so" exec-directory))))
|
|
|
45 (dynamic-call "emacs_canna_init" handle))
|
|
|
46 )
|
|
|
47
|
|
|
48 (defvar self-insert-after-hook nil)
|
|
|
49 ;; (defalias 'self-insert-internal 'self-insert-command)
|
|
|
50 ;; end
|
|
|
51
|
|
|
52 (defconst canna-rcs-version
|
|
219
|
53 "$Id: canna.el,v 1.9 1997/12/06 22:26:21 steve Exp $")
|
|
70
|
54
|
|
|
55 (defun canna-version ()
|
|
120
|
56 "Display version of canna.el in mini-buffer."
|
|
70
|
57 (interactive)
|
|
120
|
58 (message (concat
|
|
|
59 (substring canna-rcs-version
|
|
|
60 5
|
|
|
61 (if (string-match "[0-9] [a-z]" canna-rcs-version)
|
|
|
62 (1+ (match-beginning 0))
|
|
|
63 ))
|
|
|
64 " ...")))
|
|
|
65
|
|
219
|
66 ;; (require 'emu)
|
|
120
|
67
|
|
|
68 (if running-xemacs
|
|
|
69 (defun canna-self-insert-string (string)
|
|
|
70 (let ((len (length string))
|
|
|
71 (i 0)
|
|
|
72 ;; $BA^F~$NESCf$G(B blink $B$,5/$-$k$H$&$C$H$*$7$$$N$G!"(B
|
|
|
73 ;; $B0l;~E*$K(B blink $B$rM^;_$9$k!#(B
|
|
|
74 (blink-matching-paren nil))
|
|
|
75 (while (< i len)
|
|
|
76 (self-insert-internal (aref canna-kakutei-string i))
|
|
|
77 (setq i (1+ i))
|
|
|
78 )))
|
|
|
79 (defalias 'canna-self-insert-string 'insert)
|
|
|
80 )
|
|
|
81
|
|
70
|
82
|
|
|
83 ;;; $B$+$s$J$NJQ?t(B
|
|
|
84
|
|
|
85 (defvar canna-save-undo-text-predicate nil)
|
|
|
86 (defvar canna-undo-hook nil)
|
|
|
87
|
|
|
88 (defvar canna-do-keybind-for-functionkeys t)
|
|
|
89 (defvar canna-use-functional-numbers nil)
|
|
|
90 (defvar canna-use-space-key-as-henkan-region t)
|
|
|
91
|
|
|
92 (defvar canna-server nil)
|
|
|
93 (defvar canna-file nil)
|
|
|
94
|
|
|
95 (defvar canna-underline nil)
|
|
|
96 (defvar canna-with-fences (not canna-underline))
|
|
|
97
|
|
|
98 (defvar canna-initialize-minibuffer-state-when-exit nil
|
|
|
99 "*Non-nil $B$N$H$-$O(B, $B%_%K%P%C%U%!$rH4$1$k;~F|K\8l>uBV$r=i4|2=$9$k(B.")
|
|
|
100
|
|
|
101 (defvar canna-inhibit-hankakukana nil
|
|
|
102 "*Non-nil $B$N;~!";z<oJQ49$GH>3Q$+$J$KJQ49$7$J$$(B")
|
|
|
103
|
|
|
104 ;;;
|
|
|
105 ;;; $B%b!<%I%i%$%s$N=$@0(B
|
|
|
106 ;;;
|
|
|
107
|
|
|
108 (defvar canna:*kanji-mode-string* "[ $B$"(B ]")
|
|
|
109 (defvar canna:*alpha-mode-string* "$B$+$s$J(B")
|
|
|
110 (defvar canna:*saved-mode-string* "[ $B$"(B ]")
|
|
|
111
|
|
|
112 (defvar mode-line-canna-mode canna:*alpha-mode-string*)
|
|
|
113 (defvar mode-line-canna-mode-in-minibuffer canna:*alpha-mode-string*)
|
|
|
114
|
|
|
115 (defvar display-minibuffer-mode-in-minibuffer nil) ; same name as TAKANA
|
|
|
116 ; $B$?$+$J$G$O(B t $B$,%G%U%)%k%H$@$1$I!"(Bnil $B$r%G%U%)%k%H$K$7$F$*$3$&$+$J!#(B
|
|
|
117
|
|
|
118 (make-variable-buffer-local 'mode-line-canna-mode)
|
|
|
119
|
|
|
120 ; select-window-hook $B$O(B mule $B$+$iF~$C$?$s$@$H;W$&$1$I!"(B
|
|
|
121 ; $B$3$l$,L5$$$H(B preprompt $B$,$"$C$F$b$I$&$7$h$&$b$J$$$N$G$J$$$H$-$O(B
|
|
|
122 ; display-minibuffer-mode-in-minibuffer $B$r(B nil $B$K$9$k!#(B
|
|
|
123
|
|
|
124 (if (not (boundp 'select-window-hook))
|
|
|
125 (setq display-minibuffer-mode-in-minibuffer nil))
|
|
|
126
|
|
|
127 (defun canna:select-window-hook (old new)
|
|
|
128 (if (and (eq old (minibuffer-window))
|
|
|
129 (not (eq new (minibuffer-window))))
|
|
|
130 (save-excursion
|
|
|
131 (set-buffer (window-buffer (minibuffer-window)))
|
|
|
132 ;; minibuffer$B$N%G%U%)%k%H$O%"%k%U%!%Y%C%H%b!<%I(B
|
|
|
133 (setq mode-line-canna-mode-in-minibuffer canna:*alpha-mode-string*
|
|
|
134 canna:*japanese-mode-in-minibuffer* nil
|
|
|
135 minibuffer-preprompt nil)))
|
|
|
136 (if (eq new (minibuffer-window))
|
|
|
137 (setq minibuffer-window-selected t)
|
|
|
138 (setq minibuffer-window-selected nil)))
|
|
|
139
|
|
|
140 ; egg:select-window-hook $B$G$b==J,$J$N$G!"(Begg:select-window-hook $B$,(B
|
|
|
141 ; $B@_Dj$5$l$F$$$J$$>l9g$N$_Dj5A$9$k!#(B
|
|
|
142
|
|
|
143 ; $BNI$/9M$($F$_$k$H(B display-minibuffer-mode-in-minibuffer $B$,(B t $B$N;~$O(B
|
|
|
144 ; $B$d$O$j>e5-$N(B canna:select-window-hook $B$,I,MW$@$J$"!#$I$&$7$h$&!#(B
|
|
|
145
|
|
|
146 (if (and (boundp 'select-window-hook)
|
|
|
147 (not (eq select-window-hook 'egg:select-window-hook)))
|
|
|
148 (setq select-window-hook 'canna:select-window-hook))
|
|
|
149
|
|
|
150 (defun mode-line-canna-mode-update (str)
|
|
|
151 (if (eq (current-buffer) (window-buffer (minibuffer-window)))
|
|
|
152 (if (and display-minibuffer-mode-in-minibuffer
|
|
|
153 (boundp 'minibuffer-preprompt))
|
|
|
154 (setq minibuffer-preprompt str)
|
|
|
155 ;else
|
|
|
156 (setq mode-line-canna-mode-in-minibuffer str))
|
|
120
|
157 (setq mode-line-canna-mode str) )
|
|
|
158 (set-buffer-modified-p (buffer-modified-p)) )
|
|
70
|
159
|
|
|
160 ;; memq $B$r6/D4$9$k$J$i!"0J2<$@$,!"(B
|
|
|
161 ;(defun canna:memq-recursive (a l)
|
|
|
162 ; (or (eq a l)
|
|
|
163 ; (and (consp l)
|
|
|
164 ; (or (canna:memq-recursive a (car l))
|
|
|
165 ; (canna:memq-recursive a (cdr l)) ))))
|
|
|
166 ;; $B<!$NDj5A$r;H$*$&(B...
|
|
|
167 (defun canna:memq-recursive (a l)
|
|
|
168 (if (atom l) (eq a l)
|
|
|
169 (or (canna:memq-recursive a (car l))
|
|
|
170 (canna:memq-recursive a (cdr l)) )))
|
|
|
171
|
|
|
172 (defun canna:create-mode-line ()
|
|
120
|
173 "Add string of Canna status into mode-line."
|
|
|
174 (cond (running-xemacs
|
|
|
175 (or (canna:memq-recursive 'mode-line-canna-mode
|
|
|
176 default-modeline-format)
|
|
|
177 (setq-default default-modeline-format
|
|
138
|
178 (append '("" mode-line-canna-mode)
|
|
120
|
179 default-modeline-format))
|
|
|
180 )
|
|
|
181 (mapcar (function
|
|
|
182 (lambda (buffer)
|
|
|
183 (save-excursion
|
|
|
184 (set-buffer buffer)
|
|
|
185 (or (canna:memq-recursive 'mode-line-canna-mode
|
|
|
186 modeline-format)
|
|
|
187 (setq modeline-format
|
|
138
|
188 (append '("" mode-line-canna-mode)
|
|
120
|
189 modeline-format))
|
|
|
190 )
|
|
|
191 )))
|
|
|
192 (buffer-list))
|
|
|
193 )
|
|
|
194 (t
|
|
|
195 (or (canna:memq-recursive 'mode-line-canna-mode mode-line-format)
|
|
|
196 (setq-default
|
|
|
197 mode-line-format
|
|
|
198 (append (list (list 'minibuffer-window-selected
|
|
|
199 (list 'display-minibuffer-mode-in-minibuffer
|
|
|
200 "-" "m") "-")
|
|
|
201 (list 'minibuffer-window-selected
|
|
|
202 (list 'display-minibuffer-mode-in-minibuffer
|
|
|
203 'mode-line-canna-mode
|
|
|
204 'mode-line-canna-mode-in-minibuffer)
|
|
|
205 'mode-line-canna-mode))
|
|
|
206 mode-line-format))
|
|
|
207 )))
|
|
|
208 (mode-line-canna-mode-update mode-line-canna-mode))
|
|
70
|
209
|
|
|
210 (defun canna:mode-line-display ()
|
|
|
211 (mode-line-canna-mode-update mode-line-canna-mode))
|
|
|
212
|
|
|
213 ;;;
|
|
|
214 ;;; Canna local variables
|
|
|
215 ;;;
|
|
|
216
|
|
|
217 (defvar canna:*japanese-mode* nil "T if canna mode is ``japanese''.")
|
|
|
218 (make-variable-buffer-local 'canna:*japanese-mode*)
|
|
|
219 (set-default 'canna:*japanese-mode* nil)
|
|
|
220
|
|
|
221 (defvar canna:*japanese-mode-in-minibuffer* nil
|
|
|
222 "T if canna mode is ``japanese'' in minibuffer.")
|
|
|
223
|
|
|
224 (defvar canna:*exit-japanese-mode* nil)
|
|
|
225 (defvar canna:*fence-mode* nil)
|
|
|
226 ;(make-variable-buffer-local 'canna:*fence-mode*)
|
|
|
227 ;(setq-default canna:*fence-mode* nil)
|
|
|
228
|
|
|
229 ;;;
|
|
|
230 ;;; global variables
|
|
|
231 ;;;
|
|
|
232
|
|
|
233 (defvar canna-sys:*global-map* (copy-keymap global-map))
|
|
|
234 (defvar canna:*region-start* (make-marker))
|
|
|
235 (defvar canna:*region-end* (make-marker))
|
|
|
236 (defvar canna:*spos-undo-text* (make-marker))
|
|
|
237 (defvar canna:*epos-undo-text* (make-marker))
|
|
|
238 (defvar canna:*undo-text-yomi* nil)
|
|
|
239 (defvar canna:*local-map-backup* nil)
|
|
|
240 (defvar canna:*last-kouho* 0)
|
|
|
241 (defvar canna:*initialized* nil)
|
|
|
242 (defvar canna:*previous-window* nil)
|
|
|
243 (defvar canna:*minibuffer-local-map-backup* nil)
|
|
|
244 (defvar canna:*cursor-was-in-minibuffer* nil)
|
|
|
245 (defvar canna:*menu-buffer* " *menu*")
|
|
|
246 (defvar canna:*saved-minibuffer*)
|
|
|
247 (defvar canna:*saved-redirection* nil)
|
|
|
248 (defvar canna:*use-region-as-henkan-region* nil)
|
|
|
249 (make-variable-buffer-local 'canna:*use-region-as-henkan-region*)
|
|
|
250 (setq-default canna:*use-region-as-henkan-region* nil)
|
|
|
251
|
|
|
252 ;;;
|
|
|
253 ;;; $B?'$N@_Dj(B
|
|
|
254 ;;;
|
|
|
255 (defvar canna-use-color nil
|
|
|
256 "*Non-nil $B$G%+%i!<%G%#%9%W%l%$$G?'$rIU$1$k(B.
|
|
|
257 t $B$N;~$O%G%U%)%k%H$N?'$r;HMQ$9$k!#(B
|
|
|
258 $B?'$r;XDj$7$?$$;~$O(B, \"$BFI$_$N?'(B\", \"$BJQ49BP>]$N?'(B\", \"$BA*BrBP>]$N?'(B\" $B$N(B
|
|
|
259 $B%j%9%H$r@_Dj$9$k(B")
|
|
|
260 (defvar canna:color-p nil "$B?'$,;H$($k$+(B")
|
|
|
261 (defvar canna:attr-mode nil "$B8=:_$N%G%#%9%W%l%$%b!<%I(B")
|
|
|
262 (defvar canna:attr-yomi nil "$BFI$_$N?'B0@-(B")
|
|
|
263 (defvar canna:attr-taishou nil "$BJQ49BP>]ItJ,$N?'B0@-(B")
|
|
|
264 (defvar canna:attr-select nil
|
|
|
265 "$B%_%K%P%C%U%!J,N%;~$N%a%K%e!<$NA*BrBP>]HV9f$N?'B0@-(B")
|
|
|
266 (defvar canna:attribute-alist ;colored by tagu@ae.keio.ac.jp
|
|
|
267 '((yomi (normal . "red")
|
|
|
268 (reverse . "moccasin"))
|
|
|
269 (taishou (normal . "blue/lavender")
|
|
|
270 (reverse . "yellow/cadet blue"))
|
|
|
271 (select (normal . "DarkOliveGreen1/cadet blue")
|
|
|
272 (reverse . "light sea green/burlywood1")))
|
|
|
273 "$B$+$s$JJQ49;~$NG[?'$N(Balist")
|
|
|
274
|
|
|
275 (make-variable-buffer-local (defvar canna:*yomi-overlay* nil))
|
|
|
276 (make-variable-buffer-local (defvar canna:*henkan-overlay* nil))
|
|
|
277 (make-variable-buffer-local (defvar canna:*select-overlay* nil))
|
|
|
278
|
|
|
279 ;;;
|
|
|
280 ;;; $B%-!<%^%C%W%F!<%V%k(B
|
|
|
281 ;;;
|
|
|
282
|
|
|
283 ;; $B%U%'%s%9%b!<%I$G$N%m!<%+%k%^%C%W(B
|
|
|
284 (defvar canna-mode-map (make-sparse-keymap))
|
|
|
285
|
|
|
286 (let ((ch 0))
|
|
|
287 (while (<= ch 127)
|
|
|
288 (define-key canna-mode-map (make-string 1 ch) 'canna-functional-insert-command)
|
|
|
289 (setq ch (1+ ch))))
|
|
|
290
|
|
120
|
291 (cond (running-xemacs
|
|
|
292 (define-key canna-mode-map [up] "\C-p")
|
|
|
293 (define-key canna-mode-map [(shift up)] "\C-p")
|
|
|
294 (define-key canna-mode-map [(control up)] "\C-p")
|
|
|
295 (define-key canna-mode-map [down] "\C-n")
|
|
|
296 (define-key canna-mode-map [(shift down)] "\C-n")
|
|
|
297 (define-key canna-mode-map [(control down)] "\C-n")
|
|
|
298 (define-key canna-mode-map [right] "\C-f")
|
|
|
299 (define-key canna-mode-map [(shift right)] "\C-f")
|
|
|
300 (define-key canna-mode-map [(control right)] "\C-f")
|
|
|
301 (define-key canna-mode-map [left] "\C-b")
|
|
|
302 (define-key canna-mode-map [(shift left)] "\C-b")
|
|
|
303 (define-key canna-mode-map [(control left)] "\C-b")
|
|
|
304 (define-key canna-mode-map [kanji] " ")
|
|
|
305 (define-key canna-mode-map [(control space)] [(control @)])
|
|
|
306 )
|
|
|
307 (t
|
|
|
308 (define-key canna-mode-map [up] [?\C-p])
|
|
|
309 (define-key canna-mode-map [S-up] [?\C-p])
|
|
|
310 (define-key canna-mode-map [C-up] [?\C-p])
|
|
|
311 (define-key canna-mode-map [down] [?\C-n])
|
|
|
312 (define-key canna-mode-map [S-down] [?\C-n])
|
|
|
313 (define-key canna-mode-map [C-down] [?\C-n])
|
|
|
314 (define-key canna-mode-map [right] [?\C-f])
|
|
|
315 (define-key canna-mode-map [S-right] [?\C-f])
|
|
|
316 (define-key canna-mode-map [C-right] [?\C-f])
|
|
|
317 (define-key canna-mode-map [left] [?\C-b])
|
|
|
318 (define-key canna-mode-map [S-left] [?\C-b])
|
|
|
319 (define-key canna-mode-map [C-left] [?\C-b])
|
|
|
320 (define-key canna-mode-map [kanji] [? ])
|
|
|
321 (define-key canna-mode-map [?\C- ] [?\C-@])
|
|
|
322 ))
|
|
70
|
323
|
|
|
324 ;; $B%_%K%P%C%U%!$K2?$+$rI=<($7$F$$$k;~$N%m!<%+%k%^%C%W(B
|
|
|
325 (defvar canna-minibuffer-mode-map (make-sparse-keymap))
|
|
|
326
|
|
|
327 (let ((ch 0))
|
|
|
328 (while (<= ch 127)
|
|
|
329 (define-key canna-minibuffer-mode-map (make-string 1 ch) 'canna-minibuffer-insert-command)
|
|
|
330 (setq ch (1+ ch))))
|
|
|
331
|
|
120
|
332 (cond (running-xemacs
|
|
|
333 (define-key canna-minibuffer-mode-map [up] "\C-p")
|
|
|
334 (define-key canna-minibuffer-mode-map [(shift up)] "\C-p")
|
|
|
335 (define-key canna-minibuffer-mode-map [(control up)] "\C-p")
|
|
|
336 (define-key canna-minibuffer-mode-map [down] "\C-n")
|
|
|
337 (define-key canna-minibuffer-mode-map [(shift down)] "\C-n")
|
|
|
338 (define-key canna-minibuffer-mode-map [(control down)] "\C-n")
|
|
|
339 (define-key canna-minibuffer-mode-map [right] "\C-f")
|
|
|
340 (define-key canna-minibuffer-mode-map [(shift right)] "\C-f")
|
|
|
341 (define-key canna-minibuffer-mode-map [(control right)] "\C-f")
|
|
|
342 (define-key canna-minibuffer-mode-map [left] "\C-b")
|
|
|
343 (define-key canna-minibuffer-mode-map [(shift left)] "\C-b")
|
|
|
344 (define-key canna-minibuffer-mode-map [(control left)] "\C-b")
|
|
|
345 (define-key canna-minibuffer-mode-map [kanji] " ")
|
|
|
346 (define-key canna-minibuffer-mode-map [(control space)] [(control @)])
|
|
|
347 )
|
|
|
348 (t
|
|
|
349 (define-key canna-minibuffer-mode-map [up] [?\C-p])
|
|
|
350 (define-key canna-minibuffer-mode-map [S-up] [?\C-p])
|
|
|
351 (define-key canna-minibuffer-mode-map [C-up] [?\C-p])
|
|
|
352 (define-key canna-minibuffer-mode-map [down] [?\C-n])
|
|
|
353 (define-key canna-minibuffer-mode-map [S-down] [?\C-n])
|
|
|
354 (define-key canna-minibuffer-mode-map [C-down] [?\C-n])
|
|
|
355 (define-key canna-minibuffer-mode-map [right] [?\C-f])
|
|
|
356 (define-key canna-minibuffer-mode-map [S-right] [?\C-f])
|
|
|
357 (define-key canna-minibuffer-mode-map [C-right] [?\C-f])
|
|
|
358 (define-key canna-minibuffer-mode-map [left] [?\C-b])
|
|
|
359 (define-key canna-minibuffer-mode-map [S-left] [?\C-b])
|
|
|
360 (define-key canna-minibuffer-mode-map [C-left] [?\C-b])
|
|
|
361 (define-key canna-minibuffer-mode-map [kanji] [? ])
|
|
|
362 (define-key canna-minibuffer-mode-map [?\C- ] [?\C-@])
|
|
|
363 ))
|
|
70
|
364
|
|
|
365 ;;;
|
|
|
366 ;;; $B%0%m!<%P%k4X?t$N=q$-BX$((B
|
|
|
367 ;;;
|
|
|
368
|
|
|
369
|
|
|
370 ;; Keyboard quit
|
|
|
371
|
|
|
372 ;(if (not (fboundp 'canna-sys:keyboard-quit))
|
|
|
373 ; (fset 'canna-sys:keyboard-quit (symbol-function 'keyboard-quit)) )
|
|
|
374
|
|
|
375 ;(defun canna:keyboard-quit ()
|
|
|
376 ; "See documents for canna-sys:keyboard-quit"
|
|
|
377 ; (interactive)
|
|
|
378 ; (if canna:*japanese-mode*
|
|
|
379 ; (progn
|
|
|
380 ;; (setq canna:*japanese-mode* nil)
|
|
|
381 ; (setq canna:*fence-mode* nil)
|
|
120
|
382 ; (if (boundp 'disable-undo)
|
|
|
383 ; (setq disable-undo canna:*fence-mode*))
|
|
70
|
384 ; (canna:mode-line-display) ))
|
|
|
385 ; (canna-sys:keyboard-quit) )
|
|
|
386
|
|
|
387 ;; Abort recursive edit
|
|
|
388
|
|
|
389 ;(if (not (fboundp 'canna-sys:abort-recursive-edit))
|
|
|
390 ; (fset 'canna-sys:abort-recursive-edit
|
|
|
391 ; (symbol-function 'abort-recursive-edit)) )
|
|
|
392
|
|
|
393 ;(defun canna:abort-recursive-edit ()
|
|
|
394 ; "see documents for canna-sys:abort-recursive-edit"
|
|
|
395 ; (interactive)
|
|
|
396 ; (if canna:*japanese-mode*
|
|
|
397 ; (progn
|
|
|
398 ; (setq canna:*japanese-mode* nil)
|
|
|
399 ; (setq canna:*fence-mode* nil)
|
|
120
|
400 ; (if (boundp 'disable-undo)
|
|
|
401 ; (setq disable-undo canna:*fence-mode*))
|
|
70
|
402 ; (canna:mode-line-display) ))
|
|
|
403 ; (canna-sys:abort-recursive-edit) )
|
|
|
404
|
|
|
405 ;; Exit-minibuffer
|
|
|
406
|
|
|
407 (defun canna:exit-minibuffer ()
|
|
|
408 "Exit minibuffer turning off canna Japanese mode.
|
|
|
409 See also document for canna:saved-exit-minibuffer."
|
|
|
410 (interactive)
|
|
|
411 (if canna-initialize-minibuffer-state-when-exit
|
|
|
412 (setq canna:*japanese-mode-in-minibuffer* nil
|
|
|
413 mode-line-canna-mode-in-minibuffer canna:*alpha-mode-string*))
|
|
|
414 )
|
|
|
415
|
|
|
416 (add-hook 'minibuffer-exit-hook 'canna:exit-minibuffer)
|
|
|
417
|
|
|
418 ;; kill-emacs
|
|
|
419
|
|
|
420 (add-hook 'kill-emacs-hook 'canna:finalize)
|
|
|
421
|
|
|
422 ;;;
|
|
|
423 ;;; function for mini-buffer
|
|
|
424 ;;;
|
|
|
425
|
|
|
426 (defun adjust-minibuffer-mode ()
|
|
|
427 (if (eq (current-buffer) (window-buffer (minibuffer-window)))
|
|
|
428 (progn
|
|
|
429 (setq canna:*japanese-mode* canna:*japanese-mode-in-minibuffer*)
|
|
|
430 t)
|
|
|
431 nil))
|
|
|
432
|
|
|
433 ;;;
|
|
|
434 ;;; keyboard input for japanese language
|
|
|
435 ;;;
|
|
|
436
|
|
|
437 (defun canna-functional-insert-command (arg)
|
|
|
438 "Use input character as a key of complex translation input such as\n\
|
|
|
439 kana-to-kanji translation."
|
|
|
440 (interactive "*p")
|
|
98
|
441 (let ((ch))
|
|
|
442 (if (char-or-char-int-p arg)
|
|
|
443 (setq ch last-command-char)
|
|
|
444 (setq ch (event-to-character last-command-event)))
|
|
|
445 (canna:functional-insert-command2 ch arg) ))
|
|
70
|
446
|
|
|
447 (defun canna:functional-insert-command2 (ch arg)
|
|
|
448 "This function actualy isert a converted Japanese string."
|
|
|
449 ;; $B$3$N4X?t$OM?$($i$l$?J8;z$rF|K\8lF~NO$N$?$a$N%-!<F~NO$H$7$F<h$j07(B
|
|
|
450 ;; $B$$!"F|K\8lF~NO$NCf4V7k2L$r4^$a$?=hM}$r(BEmacs$B$N%P%C%U%!$KH?1G$5$;$k(B
|
|
|
451 ;; $B4X?t$G$"$k!#(B
|
|
|
452 (canna:display-candidates (canna-key-proc ch)) )
|
|
|
453
|
|
|
454 (defun canna:delete-last-preedit ()
|
|
|
455 (if (not (zerop canna:*last-kouho*))
|
|
|
456 (progn
|
|
|
457 (if canna-underline
|
|
|
458 ; $B$^$:!"B0@-$r>C$9!#(B
|
|
|
459 (progn
|
|
|
460 (canna:henkan-attr-off canna:*region-start* canna:*region-end*)
|
|
|
461 (canna:yomi-attr-off canna:*region-start* canna:*region-end*)))
|
|
|
462 (delete-region canna:*region-start* canna:*region-end*)
|
|
|
463 (setq canna:*last-kouho* 0) )))
|
|
|
464
|
|
|
465 (defun canna:insert-fixed (strs)
|
|
|
466 (cond ((> strs 0)
|
|
|
467 (cond ((and canna-kakutei-yomi
|
|
|
468 (or (null canna-save-undo-text-predicate)
|
|
|
469 (funcall canna-save-undo-text-predicate
|
|
|
470 (cons canna-kakutei-yomi
|
|
|
471 canna-kakutei-romaji) )))
|
|
|
472 (setq canna:*undo-text-yomi*
|
|
|
473 (cons canna-kakutei-yomi canna-kakutei-romaji))
|
|
|
474 (set-marker canna:*spos-undo-text* (point))
|
|
|
475 ;;
|
|
|
476 ;; update kbnes
|
|
120
|
477 (canna-self-insert-string canna-kakutei-string)
|
|
70
|
478 ;; $BL$3NDj$NJ8;z$,$J$/!"3NDjJ8;zNs$N:G8e$,JD$83g8L$N(B
|
|
|
479 ;; $BN`$@$C$?$H$-$O(B blink $B$5$;$k!#(B
|
|
|
480 (if (and canna-empty-info
|
|
|
481 (eq (char-syntax (char-before (point))) ?\)) )
|
|
|
482 (blink-matching-open))
|
|
|
483
|
|
|
484 ; (if overwrite-mode
|
|
|
485 ; (let ((num strs)
|
|
|
486 ; (kanji-compare 128))
|
|
|
487 ; (catch 'delete-loop
|
|
|
488 ; (while (> num 0)
|
|
|
489 ; (if (eolp)
|
|
|
490 ; (throw 'delete-loop nil))
|
|
|
491 ; (if (>= (following-char) kanji-compare)
|
|
|
492 ; (setq num (1- num)))
|
|
|
493 ; (delete-char 1)
|
|
|
494 ; (setq num (1- num))))))
|
|
|
495 ;; end kbnes
|
|
|
496 ; (insert canna-kakutei-string)
|
|
|
497 (if self-insert-after-hook
|
|
|
498 (funcall self-insert-after-hook
|
|
|
499 canna:*region-start* canna:*region-end*))
|
|
|
500 (canna:do-auto-fill)
|
|
|
501 (set-marker canna:*epos-undo-text* (point)) )
|
|
|
502 (t
|
|
|
503 ;;
|
|
|
504 ;; update kbnes
|
|
120
|
505 (canna-self-insert-string canna-kakutei-string)
|
|
70
|
506 ;; $BL$3NDj$NJ8;z$,$J$/!"3NDjJ8;zNs$N:G8e$,JD$83g8L$N(B
|
|
|
507 ;; $BN`$@$C$?$H$-$O(B blink $B$5$;$k!#(B
|
|
|
508 (if (and canna-empty-info
|
|
|
509 (eq (char-syntax (char-before (point))) ?\)) )
|
|
|
510 (blink-matching-open))
|
|
|
511
|
|
|
512 ; (if overwrite-mode
|
|
|
513 ; (let ((num strs)
|
|
|
514 ; (kanji-compare 128))
|
|
|
515 ; (catch 'delete-loop
|
|
|
516 ; (while (> num 0)
|
|
|
517 ; (if (eolp)
|
|
|
518 ; (throw 'delete-loop nil))
|
|
|
519 ; (if (>= (following-char) kanji-compare)
|
|
|
520 ; (setq num (1- num)))
|
|
|
521 ; (delete-char 1)
|
|
|
522 ; (setq num (1- num))))))
|
|
|
523 ;; end kbnes
|
|
|
524 ; (insert canna-kakutei-string)
|
|
|
525 (if self-insert-after-hook
|
|
|
526 (funcall self-insert-after-hook
|
|
|
527 canna:*region-start* canna:*region-end*))
|
|
|
528 (canna:do-auto-fill) ))
|
|
|
529 ) ))
|
|
|
530
|
|
|
531 (defun canna:insert-preedit ()
|
|
|
532 (cond ((> canna-henkan-length 0)
|
|
|
533 (set-marker canna:*region-start* (point))
|
|
|
534 (if canna-with-fences
|
|
|
535 (progn
|
|
|
536 (insert "||")
|
|
|
537 (set-marker canna:*region-end* (point))
|
|
|
538 (backward-char 1)
|
|
|
539 ))
|
|
|
540 (insert canna-henkan-string)
|
|
|
541 (if (not canna-with-fences)
|
|
|
542 (set-marker canna:*region-end* (point)) )
|
|
|
543 (if canna-underline
|
|
|
544 (canna:yomi-attr-on canna:*region-start* canna:*region-end*))
|
|
|
545 (setq canna:*last-kouho* canna-henkan-length)
|
|
|
546 ))
|
|
120
|
547
|
|
|
548 ;; $B8uJdNN0h$G$O6/D4$7$?$$J8;zNs$,B8:_$9$k$b$N$H9M$($i(B
|
|
|
549 ;; $B$l$k!#6/D4$7$?$$J8;z$O(BEmacs$B$G$O%+!<%=%k%]%8%7%g%s$K$FI=<((B
|
|
|
550 ;; $B$9$k$3$H$H$9$k!#6/D4$7$?$$J8;z$,$J$$$N$G$"$l$P!"%+!<%=%k(B
|
|
|
551 ;; $B$O0lHV8e$NItJ,(B($BF~NO$,9T$o$l$k%]%$%s%H(B)$B$KCV$$$F$*$/!#(B
|
|
|
552
|
|
|
553 ;; $B%+!<%=%k$r0\F0$9$k!#(B
|
|
|
554 (if (not canna-underline)
|
|
|
555 (backward-char
|
|
|
556 (- canna:*last-kouho*
|
|
|
557 ;; $B%+!<%=%k0LCV$O!"H?E>I=<(ItJ,$,B8:_$7$J$$$N$G$"$l$P!"(B
|
|
|
558 ;; $B8uJdJ8;zNs$N:G8e$NItJ,$H$7!"H?E>I=<(ItJ,$,B8:_$9$k$N(B
|
|
|
559 ;; $B$G$"$l$P!"$=$NItJ,$N;O$a$H$9$k!#(B
|
|
|
560 (cond ((zerop canna-henkan-revlen)
|
|
|
561 canna:*last-kouho*)
|
|
|
562 (t canna-henkan-revpos) )) )
|
|
|
563 (if (and (> canna-henkan-revlen 0)
|
|
|
564 (> canna-henkan-length 0))
|
|
|
565 ; $B8uJd$ND9$5$,(B0$B$G$J$/!"(B
|
|
|
566 ; $BH?E>I=<($ND9$5$,(B0$B$G$J$1$l$P!"(B
|
|
|
567 ; $B$=$NItJ,$rJQE>I=<($9$k!#(B
|
|
|
568 (let ((start (+ canna:*region-start*
|
|
|
569 (if canna-with-fences 1 0)
|
|
|
570 canna-henkan-revpos) ))
|
|
|
571 (if canna-underline
|
|
|
572 (canna:henkan-attr-on start
|
|
|
573 (+ start canna-henkan-revlen)))))
|
|
|
574 ) )
|
|
70
|
575
|
|
|
576 (defun canna:display-candidates (strs)
|
|
|
577 (cond ((stringp strs) ; $B%(%i!<$,5/$3$C$?>l9g(B
|
|
|
578 (beep)
|
|
|
579 (message strs) )
|
|
|
580 (canna-henkan-string
|
|
|
581 ;; $B$b$78uJdI=<($,A0$N7k2L$+$iJQ$o$C$F$$$J$/$J$$$H$-$O(B......
|
|
|
582
|
|
|
583 ;; $B<h$j9g$($::G=i$OA0$K=q$$$F$*$$$?Cf4V7k2L$r>C$9!#(B
|
|
|
584 (canna:delete-last-preedit)
|
|
|
585
|
|
|
586 ;; $B3NDj$7$?J8;zNs$,$"$l$P$=$l$rA^F~$9$k!#(B
|
|
|
587 (canna:insert-fixed strs)
|
|
|
588
|
|
|
589 ;; $B<!$O8uJd$K$D$$$F$N:n6H$G$"$k!#(B
|
|
|
590
|
|
|
591 ;; $B8uJd$rA^F~$9$k!#8uJd$O=DK@FsK\$K$F64$^$l$k!#(B
|
|
|
592 (canna:insert-preedit)
|
|
|
593 ))
|
|
|
594
|
|
|
595 ;; $B%b!<%I$rI=$9J8;zNs$,B8:_$9$l$P$=$l$r%b!<%I$H$7$F<h$j07$&!#(B
|
|
|
596 (if (stringp canna-mode-string)
|
|
|
597 (mode-line-canna-mode-update canna-mode-string))
|
|
|
598
|
|
|
599 ;; $B8uJdI=<($,$J$1$l$P%U%'%s%9%b!<%I$+$iH4$1$k!#(B
|
|
|
600 (cond (canna-empty-info (canna:quit-canna-mode)))
|
|
|
601
|
|
|
602 ;; $B%_%K%P%C%U%!$K=q$/$3$H$,B8:_$9$k$N$G$"$l$P!"$=$l$r%_%K%P%C%U%!(B
|
|
|
603 ;; $B$KI=<($9$k!#(B
|
|
|
604 (cond (canna-ichiran-string
|
|
|
605 (canna:minibuffer-input canna-ichiran-string
|
|
|
606 canna-ichiran-length
|
|
|
607 canna-ichiran-revpos
|
|
|
608 canna-ichiran-revlen
|
|
|
609 strs) )
|
|
|
610 (canna:*cursor-was-in-minibuffer*
|
|
|
611 ; (select-frame (window-frame (minibuffer-window)))
|
|
|
612 (select-window (minibuffer-window))
|
|
|
613 (set-window-buffer (minibuffer-window)
|
|
|
614 (get-buffer-create canna:*menu-buffer*))
|
|
|
615 (use-local-map canna-minibuffer-mode-map) ))
|
|
|
616 )
|
|
|
617
|
|
|
618 (defun canna:minibuffer-input (str len revpos revlen nfixed)
|
|
|
619 "Displaying misc informations for kana-to-kanji input."
|
|
|
620
|
|
|
621 ;; $B:n6H$r%_%K%P%C%U%!$K0\$9$N$K:]$7$F!"8=:_$N%&%#%s%I%&$N>pJs$rJ]B8(B
|
|
|
622 ;; $B$7$F$*$/!#(B
|
|
|
623 (setq canna:*previous-window* (selected-window))
|
|
|
624 ; (select-frame (window-frame (minibuffer-window)))
|
|
|
625
|
|
|
626 ;; $B<+J,$KMh$kA0$,%_%K%P%C%U%!$+$I$&$+$rJQ?t$K$G$b$$$l$F$*$$$?J}$,$$$$$J$"!#(B
|
|
|
627
|
|
|
628 (if (not canna:*cursor-was-in-minibuffer*)
|
|
|
629 (progn
|
|
|
630 ;; $B%_%K%P%C%U%!$r%/%j%"$9$k!#(B
|
|
|
631 ; (if (eq canna:*previous-window* (selected-window))
|
|
|
632 ; (progn
|
|
|
633 ; (canna:henkan-attr-off (point-min) (point-max))
|
|
|
634 ; (canna:delete-last-preedit) ))
|
|
|
635
|
|
|
636 ;; $B%_%K%P%C%U%!%&%#%s%I%&$K8uJd0lMwMQ$N%P%C%U%!$r3d$jEv$F$k!#(B
|
|
|
637 (setq canna:*saved-minibuffer* (window-buffer (minibuffer-window)))
|
|
|
638 ; (set-window-buffer (minibuffer-window)
|
|
|
639 ; (get-buffer-create canna:*menu-buffer*))
|
|
|
640 ;; modified by $B<i2,(B $BCNI'(B <morioka@jaist.ac.jp>, 1996/6/7
|
|
120
|
641 (unless running-xemacs
|
|
|
642 ;; $B$H$j$"$($:(B XEmacs $B$G$OF0$+$5$J$$$3$H$K$7$F$*$3$&(B (^_^;
|
|
|
643 (setq canna:*saved-redirection* (frame-focus (selected-frame)))
|
|
|
644 (redirect-frame-focus (selected-frame)
|
|
|
645 (window-frame (minibuffer-window)))
|
|
|
646 )
|
|
70
|
647 ;; $B%_%K%P%C%U%!$N%-!<%^%C%W$rJ]B8$7$F$*$/!#(B
|
|
|
648 (setq canna:*minibuffer-local-map-backup* (current-local-map))
|
|
|
649 ))
|
|
|
650 (select-window (minibuffer-window))
|
|
|
651 (set-window-buffer (minibuffer-window)
|
|
|
652 (get-buffer-create canna:*menu-buffer*))
|
|
|
653
|
|
|
654 (use-local-map canna-minibuffer-mode-map)
|
|
|
655
|
|
|
656 ; (canna:yomi-attr-off (point-min) (point-max) )
|
|
|
657 ; (canna:henkan-attr-off (point-min) (point-max) )
|
|
|
658 (canna:select-attr-off (point-min) (point-max) )
|
|
|
659 (setq canna:*cursor-was-in-minibuffer* t)
|
|
|
660 (delete-region (point-min) (point-max))
|
|
|
661 (if (not (eq canna:*previous-window* (selected-window)))
|
|
|
662 (setq minibuffer-window-selected nil))
|
|
|
663
|
|
|
664 (insert str)
|
|
|
665
|
|
|
666 ;; $B%_%K%P%C%U%!$GH?E>I=<($9$k$Y$-J8;z$N$H$3$m$K%+!<%=%k$r0\F0$9$k!#(B
|
|
|
667 (cond ((> revlen 0)
|
|
|
668 (backward-char (- len revpos)) ))
|
|
|
669 ;;(message "%s" (selected-frame)) (sit-for 3)
|
|
|
670 (raise-frame (window-frame (minibuffer-window)))
|
|
|
671 ; (select-frame (window-frame (minibuffer-window)))
|
|
|
672 (and canna:color-p (not (eobp))
|
|
|
673 (canna:select-attr-on (point)
|
|
|
674 (save-excursion (forward-char 1) (point))))
|
|
|
675
|
|
|
676 ;; $B%_%K%P%C%U%!$KI=<($9$k$Y$-J8;zNs$,%L%kJ8;zNs$J$N$G$"$l$P!"A0$N%&%#(B
|
|
|
677 ;; $B%s%I%&$KLa$k!#(B
|
|
|
678 (if (or (zerop len) canna-empty-info)
|
|
|
679 (progn
|
|
|
680 (setq canna:*cursor-was-in-minibuffer* nil)
|
|
|
681 (use-local-map canna:*minibuffer-local-map-backup*)
|
|
|
682
|
|
|
683 ;; $B%_%K%P%C%U%!%&%#%s%I%&$N%P%C%U%!$r85$KLa$9!#(B
|
|
|
684 (set-window-buffer (minibuffer-window) canna:*saved-minibuffer*)
|
|
|
685 ; (setq canna:*saved-minibuffer* nil)
|
|
|
686 ;; modified by $B<i2,(B $BCNI'(B <morioka@jaist.ac.jp>, 1996/6/7
|
|
120
|
687 (unless running-xemacs
|
|
|
688 ;; $B$H$j$"$($:(B XEmacs $B$G$OF0$+$5$J$$$h$&$K$7$F$*$3$&(B (^_^;
|
|
|
689 (redirect-frame-focus (window-frame canna:*previous-window*)
|
|
|
690 canna:*saved-redirection*)
|
|
|
691 )
|
|
|
692 ; $B%_%K%P%C%U%!$GF~NO$7$F$$$?$N$J$i0J2<$b$9$k!#(B
|
|
70
|
693 ; (if (eq canna:*previous-window* (selected-window))
|
|
|
694 ; (progn
|
|
|
695 ; (canna:insert-fixed nfixed)
|
|
|
696 ; (canna:insert-preedit) ))
|
|
|
697
|
|
|
698 (if (and canna-empty-info (> len 0))
|
|
|
699 (progn
|
|
|
700 ; (delete-region (point-min) (point-max))
|
|
|
701 (message str) ))
|
|
|
702 (select-window canna:*previous-window*) ))
|
|
|
703 )
|
|
|
704
|
|
|
705 (defun canna-minibuffer-insert-command (arg)
|
|
|
706 "Use input character as a key of complex translation input such as\n\
|
|
|
707 kana-to-kanji translation, even if you are in the minibuffer."
|
|
|
708 (interactive "p")
|
|
|
709 (use-local-map canna:*minibuffer-local-map-backup*)
|
|
|
710 (set-window-buffer (minibuffer-window) canna:*saved-minibuffer*)
|
|
|
711 (select-window canna:*previous-window*)
|
|
98
|
712 (let ((ch))
|
|
|
713 (if (char-or-char-int-p arg)
|
|
|
714 (setq ch last-command-char)
|
|
|
715 (setq ch (event-to-character last-command-event)))
|
|
|
716 (canna:functional-insert-command2 ch arg) ))
|
|
70
|
717
|
|
|
718 ;;;
|
|
|
719 ;;; $B$+$s$J%b!<%I$N<gLr$O!"<!$N(B canna-self-insert-command $B$G$"$k!#$3$N(B
|
|
|
720 ;;; $B%3%^%s%I$OA4$F$N%0%i%U%#%C%/%-!<$K%P%$%s%I$5$l$k!#(B
|
|
|
721 ;;;
|
|
|
722 ;;; $B$3$N4X?t$G$O!"8=:_$N%b!<%I$,F|K\8lF~NO%b!<%I$+$I$&$+$r%A%'%C%/$7$F!"(B
|
|
|
723 ;;; $BF|K\8lF~NO%b!<%I$G$J$$$N$G$"$l$P!"%7%9%F%`$N(B self-insert-command
|
|
|
724 ;;; $B$r8F$V!#F|K\8lF~NO%b!<%I$G$"$l$P!"%U%'%s%9%b!<%I$KF~$j!"(B
|
|
|
725 ;;; canna-functional-insert-command $B$r8F$V!#(B
|
|
|
726 ;;;
|
|
|
727
|
|
|
728 (if (not (boundp 'MULE)) ; for Nemacs
|
|
|
729 (defun cancel-undo-boundary ()))
|
|
|
730
|
|
|
731 (defun canna-self-insert-command (arg)
|
|
|
732 "Self insert pressed key and use it to assemble Romaji character."
|
|
|
733 (interactive "*p")
|
|
|
734 (adjust-minibuffer-mode)
|
|
|
735 (if (and canna:*japanese-mode*
|
|
|
736 ;; $B%U%'%s%9%b!<%I$@$C$?$i$b$&0lEY%U%'%s%9%b!<%I$KF~$C$?$j$7(B
|
|
|
737 ;; $B$J$$!#(B
|
|
|
738 (not canna:*fence-mode*) )
|
|
|
739 (canna:enter-canna-mode-and-functional-insert)
|
|
|
740 (progn
|
|
|
741 ;; $B0J2<$NItJ,$O(B egg.el $B$N(B 3.09 $B$N(B egg-self-insert-command $B$NItJ,$+$i(B
|
|
|
742 ;; $B%3%T!<$7!"<j$rF~$l$F$$$^$9!#(B93.11.5 kon
|
|
|
743 ;; treat continuous 20 self insert as a single undo chunk.
|
|
|
744 ;; `20' is a magic number copied from keyboard.c
|
|
|
745 ; (if (or ;92.12.20 by T.Enami
|
|
|
746 ; (not (eq last-command 'canna-self-insert-command))
|
|
|
747 ; (>= canna:*self-insert-non-undo-count* 20))
|
|
|
748 ; (setq canna:*self-insert-non-undo-count* 1)
|
|
|
749 ; (cancel-undo-boundary)
|
|
|
750 ; (setq canna:*self-insert-non-undo-count*
|
|
|
751 ; (1+ canna:*self-insert-non-undo-count*)))
|
|
|
752 (if (and (eq last-command 'canna-self-insert-command)
|
|
|
753 (> last-command-char ? ))
|
|
|
754 (cancel-undo-boundary))
|
|
|
755 (self-insert-command arg)
|
|
|
756 ; (if canna-insert-after-hook
|
|
|
757 ; (run-hooks 'canna-insert-after-hook))
|
|
|
758 (if self-insert-after-hook
|
|
|
759 (if (<= 1 arg)
|
|
|
760 (funcall self-insert-after-hook
|
|
|
761 (- (point) arg) (point)))
|
|
|
762 (if (= last-command-char ? ) (canna:do-auto-fill))))))
|
|
|
763
|
|
138
|
764 ;; wire us into pending-delete
|
|
|
765 (put 'canna-self-insert-command 'pending-delete t)
|
|
|
766
|
|
70
|
767 (defun canna-toggle-japanese-mode ()
|
|
|
768 "Toggle canna japanese mode."
|
|
|
769 (interactive)
|
|
|
770 (let ((in-minibuffer (adjust-minibuffer-mode)))
|
|
|
771 (cond (canna:*japanese-mode*
|
|
|
772 (setq canna:*japanese-mode* nil)
|
|
|
773 (canna-abandon-undo-info)
|
|
|
774 (setq canna:*use-region-as-henkan-region* nil)
|
|
|
775 (setq canna:*saved-mode-string* mode-line-canna-mode)
|
|
|
776 (mode-line-canna-mode-update canna:*alpha-mode-string*) )
|
|
|
777 (t
|
|
|
778 (setq canna:*japanese-mode* t)
|
|
|
779 (if (fboundp 'canna-query-mode)
|
|
|
780 (let ((new-mode (canna-query-mode)))
|
|
|
781 (if (string-equal new-mode "")
|
|
|
782 (setq canna:*kanji-mode-string* canna:*saved-mode-string*)
|
|
|
783 (setq canna:*kanji-mode-string* new-mode)
|
|
|
784 )) )
|
|
|
785 (mode-line-canna-mode-update canna:*kanji-mode-string*) ) )
|
|
|
786 (if in-minibuffer
|
|
|
787 (setq canna:*japanese-mode-in-minibuffer* canna:*japanese-mode*)) ))
|
|
|
788
|
|
|
789 (defun canna:initialize ()
|
|
|
790 (let ((init-val nil))
|
|
|
791 (cond (canna:*initialized*) ; initialize $B$5$l$F$$$?$i2?$b$7$J$$(B
|
|
|
792 (t
|
|
|
793 (setq canna:*initialized* t)
|
|
|
794 (setq init-val (canna-initialize
|
|
|
795 (if canna-underline 0 1)
|
|
|
796 canna-server canna-file))
|
|
|
797 (cond ((car (cdr (cdr init-val)))
|
|
|
798 (canna:output-warnings (car (cdr (cdr init-val)))) ))
|
|
|
799 (cond ((car (cdr init-val))
|
|
|
800 (error (car (cdr init-val))) ))
|
|
|
801 ) )
|
|
|
802
|
|
|
803 (if (fboundp 'canna-query-mode)
|
|
|
804 (progn
|
|
|
805 (canna-change-mode canna-mode-alpha-mode)
|
|
|
806 (setq canna:*alpha-mode-string* (canna-query-mode)) ))
|
|
|
807
|
|
|
808 (canna-do-function canna-func-japanese-mode)
|
|
|
809
|
|
|
810 (if (fboundp 'canna-query-mode)
|
|
|
811 (setq canna:*kanji-mode-string* (canna-query-mode)))
|
|
|
812
|
|
|
813 init-val))
|
|
|
814
|
|
|
815 (defun canna:finalize ()
|
|
|
816 (cond ((null canna:*initialized*)) ; initialize $B$5$l$F$$$J$+$C$?$i2?$b$7$J$$(B
|
|
|
817 (t
|
|
|
818 (setq canna:*initialized* nil)
|
|
|
819 (let ((init-val (canna-finalize)))
|
|
|
820 (cond ((car (cdr (cdr init-val)))
|
|
|
821 (canna:output-warnings (car (cdr (cdr init-val)))) ))
|
|
|
822 (cond ((car (cdr init-val))
|
|
|
823 (error (car (cdr init-val))) ))
|
|
|
824 )
|
|
|
825 (message "$B!X$+$s$J!Y$N<-=q$r%;!<%V$7$^$9!#(B")
|
|
|
826 )))
|
|
|
827
|
|
|
828 (defun canna:enter-canna-mode ()
|
|
|
829 (if (not canna:*initialized*)
|
|
|
830 (progn
|
|
|
831 (message "$B!X$+$s$J!Y$N=i4|2=$r9T$C$F$$$^$9(B....")
|
|
|
832 (canna:initialize)
|
|
|
833 (message "$B!X$+$s$J!Y$N=i4|2=$r9T$C$F$$$^$9(B....done")
|
|
|
834 ))
|
|
|
835 (canna-set-width (- (window-width (minibuffer-window))
|
|
219
|
836 ;; Inline expansion of `minibuffer-prompt-width'
|
|
|
837 (save-excursion
|
|
|
838 (set-buffer (window-buffer (minibuffer-window)))
|
|
|
839 (current-column))
|
|
70
|
840 (if (and display-minibuffer-mode-in-minibuffer
|
|
|
841 (eq (selected-window) (minibuffer-window)))
|
|
|
842 (string-width
|
|
|
843 (let ((new-mode (canna-query-mode)))
|
|
|
844 (if (string-equal new-mode "")
|
|
|
845 canna:*saved-mode-string*
|
|
|
846 new-mode)))
|
|
|
847 0)))
|
|
|
848 (setq canna:*local-map-backup* (current-local-map))
|
|
|
849 (setq canna:*fence-mode* t)
|
|
|
850 ;; XEmacs change:
|
|
|
851 (buffer-disable-undo (current-buffer))
|
|
120
|
852 ;; (if (boundp 'disable-undo)
|
|
|
853 ;; (setq disable-undo canna:*fence-mode*))
|
|
70
|
854 (use-local-map canna-mode-map))
|
|
|
855
|
|
|
856 (defun canna:enter-canna-mode-and-functional-insert ()
|
|
|
857 (canna:enter-canna-mode)
|
|
|
858 (setq canna:*use-region-as-henkan-region* nil)
|
|
|
859 (setq unread-command-events (list last-command-event)))
|
|
|
860
|
|
|
861 (defun canna:quit-canna-mode ()
|
|
|
862 (cond (canna:*fence-mode*
|
|
|
863 (use-local-map canna:*local-map-backup*)
|
|
|
864 (setq canna:*fence-mode* nil)
|
|
|
865 (if canna:*exit-japanese-mode*
|
|
|
866 (progn
|
|
|
867 (setq canna:*exit-japanese-mode* nil)
|
|
|
868 (setq canna-mode-string canna:*alpha-mode-string*)
|
|
|
869 (if canna:*japanese-mode*
|
|
|
870 (canna-toggle-japanese-mode)
|
|
|
871 (mode-line-canna-mode-update canna:*alpha-mode-string*) )))
|
|
|
872 ;; XEmacs change:
|
|
|
873 (buffer-enable-undo (current-buffer))
|
|
120
|
874 ;; (if (boundp 'disable-undo)
|
|
|
875 ;; (setq disable-undo canna:*fence-mode*))
|
|
70
|
876 ))
|
|
|
877 (set-marker canna:*region-start* nil)
|
|
|
878 (set-marker canna:*region-end* nil)
|
|
|
879 )
|
|
|
880
|
|
|
881 (defun canna-touroku ()
|
|
|
882 "Register a word into a kana-to-kanji dictionary."
|
|
|
883 (interactive)
|
|
|
884 ; (if canna:*japanese-mode*
|
|
|
885 (if (not canna:*fence-mode*)
|
|
|
886 (progn
|
|
|
887 (setq canna:*exit-japanese-mode* (not canna:*japanese-mode*))
|
|
|
888 (canna:enter-canna-mode)
|
|
|
889 (canna:display-candidates (canna-touroku-string "")) )
|
|
|
890 (beep)
|
|
|
891 ))
|
|
|
892
|
|
|
893 (defun canna-without-newline (start end)
|
|
|
894 (and (not (eq start end))
|
|
|
895 (or
|
|
|
896 (and (<= end (point))
|
|
|
897 (save-excursion
|
|
|
898 (beginning-of-line)
|
|
|
899 (<= (point) start) ))
|
|
|
900 (and (<= (point) start)
|
|
|
901 (save-excursion
|
|
|
902 (end-of-line)
|
|
|
903 (<= end (point)) ))
|
|
|
904 )))
|
|
|
905
|
|
|
906 (defun canna-touroku-region (start end)
|
|
|
907 "Register a word which is indicated by region into a kana-to-kanji\n\
|
|
|
908 dictionary."
|
|
|
909 (interactive "r")
|
|
|
910 (if (canna-without-newline start end)
|
|
|
911 ; (if canna:*japanese-mode*
|
|
|
912 (if (not canna:*fence-mode*)
|
|
|
913 (progn
|
|
|
914 (setq canna:*use-region-as-henkan-region* nil)
|
|
|
915 (setq canna:*exit-japanese-mode* (not canna:*japanese-mode*))
|
|
|
916 (canna:enter-canna-mode)
|
|
|
917 (canna:display-candidates
|
|
|
918 (canna-touroku-string (buffer-substring start end))) ))
|
|
|
919 (message "$B%j!<%8%g%s$,IT@5$G$9!#%L%k%j!<%8%g%s$+!"2~9T$,4^$^$l$F$$$^$9!#(B")
|
|
|
920 ))
|
|
|
921
|
|
|
922 (defun canna-extend-mode ()
|
|
|
923 "To enter an extend-mode of Canna."
|
|
|
924 (interactive "*")
|
|
|
925 ; (if (and (not (eq (window-frame (minibuffer-window)) (selected-frame)))
|
|
|
926 ; (not canna:*fence-mode*))
|
|
|
927 ;; $B%_%K%P%C%U%!$rJ,N%$7$F$$$k;~$O0l;~E*$K%U%'%s%9%b!<%I$KF~$k(B
|
|
|
928 ;; $B$=$&$7$J$$$H%a%K%e!<$rA*$Y$J$$(B
|
|
|
929 ;; (focus$B$,%_%K%P%C%U%!$K9T$+$J$$$+$i(B)
|
|
|
930 (if (not canna:*fence-mode*)
|
|
|
931 (progn
|
|
|
932 (setq canna:*exit-japanese-mode* (not canna:*japanese-mode*))
|
|
|
933 (canna:enter-canna-mode)
|
|
|
934 (canna:display-candidates
|
|
|
935 (canna-do-function canna-func-extend-mode) ))
|
|
|
936 (beep)))
|
|
|
937
|
|
|
938 (defun canna-kigou-mode ()
|
|
|
939 "Enter symbol choosing mode."
|
|
|
940 (interactive "*")
|
|
|
941 ; (if canna:*japanese-mode*
|
|
|
942 (if (not canna:*fence-mode*)
|
|
|
943 (progn
|
|
|
944 (setq canna:*exit-japanese-mode* (not canna:*japanese-mode*))
|
|
|
945 (canna:enter-canna-mode)
|
|
|
946 (canna:display-candidates (canna-change-mode canna-mode-kigo-mode)) )
|
|
|
947 (beep)
|
|
|
948 ))
|
|
|
949
|
|
|
950 (defun canna-hex-mode ()
|
|
|
951 "Enter hex code entering mode."
|
|
|
952 (interactive "*")
|
|
|
953 ; (if canna:*japanese-mode*
|
|
|
954 (if (not canna:*fence-mode*)
|
|
|
955 (progn
|
|
|
956 (setq canna:*exit-japanese-mode* (not canna:*japanese-mode*))
|
|
|
957 (canna:enter-canna-mode)
|
|
|
958 (canna:display-candidates (canna-change-mode canna-mode-hex-mode)) )
|
|
|
959 (beep)
|
|
|
960 ))
|
|
|
961
|
|
|
962 (defun canna-bushu-mode ()
|
|
|
963 "Enter special mode to convert by BUSHU name."
|
|
|
964 (interactive "*")
|
|
|
965 ; (if canna:*japanese-mode*
|
|
|
966 (if (not canna:*fence-mode*)
|
|
|
967 (progn
|
|
|
968 (setq canna:*exit-japanese-mode* (not canna:*japanese-mode*))
|
|
|
969 (canna:enter-canna-mode)
|
|
|
970 (canna:display-candidates (canna-change-mode canna-mode-bushu-mode)) )
|
|
|
971 (beep)
|
|
|
972 ))
|
|
|
973
|
|
|
974 (defun canna-reset ()
|
|
|
975 (interactive)
|
|
|
976 (message "$B!X$+$s$J!Y$N<-=q$r%;!<%V$7$^$9!#(B");
|
|
|
977 (canna:finalize)
|
|
|
978 (message "$B!X$+$s$J!Y$N:F=i4|2=$r9T$C$F$$$^$9(B....")
|
|
|
979 (canna:initialize)
|
|
|
980 (message "$B!X$+$s$J!Y$N:F=i4|2=$r9T$C$F$$$^$9(B....done")
|
|
|
981 )
|
|
|
982
|
|
|
983
|
|
|
984 (defun canna ()
|
|
|
985 (interactive)
|
|
|
986 (message "$B!X$+$s$J!Y$r=i4|2=$7$F$$$^$9(B....")
|
|
|
987 (let (init-val)
|
|
|
988 (cond ((and (fboundp 'canna-initialize) (fboundp 'canna-change-mode) )
|
|
|
989
|
|
|
990 ;; canna $B$,;H$($k;~$O<!$N=hM}$r$9$k!#(B
|
|
|
991
|
|
|
992 ;; $BG[?'@_Dj(B (by yuuji@ae.keio.ac.jp)
|
|
|
993 (setq canna:color-p (and canna-use-color
|
|
|
994 window-system
|
|
|
995 (x-display-color-p)))
|
|
|
996 ;;$B%+%i!<$N;~(Bunderline$B%b!<%I$HF1$8>uBV$G=i4|2=$9$kI,MW$,$"$k(B
|
|
|
997 (setq canna-underline (or canna:color-p canna-underline))
|
|
|
998 (cond
|
|
|
999 (canna:color-p
|
|
|
1000 (setq canna:attr-mode
|
|
|
1001 (cond
|
|
|
1002 ((or (and (boundp 'hilit-background-mode)
|
|
|
1003 (eq hilit-background-mode 'dark))
|
|
|
1004 (string-match
|
|
|
1005 "on\\|t"
|
|
116
|
1006 (or (if running-xemacs
|
|
120
|
1007 (x-get-resource "ReverseVideo"
|
|
|
1008 "reverseVideo" 'string)
|
|
116
|
1009 (x-get-resource "ReverseVideo" "reverseVideo"))
|
|
70
|
1010 "")))
|
|
|
1011 'reverse) ;$BH?E>$7$F$$$k$J$i(B 'reverse
|
|
|
1012 (t 'normal)))
|
|
|
1013 (setq canna:attr-yomi
|
|
|
1014 (if (listp canna-use-color)
|
|
|
1015 (car canna-use-color)
|
|
|
1016 (cdr (assq canna:attr-mode
|
|
|
1017 (assq 'yomi canna:attribute-alist)))))
|
|
|
1018 (setq canna:attr-taishou
|
|
|
1019 (if (listp canna-use-color)
|
|
|
1020 (car (cdr canna-use-color))
|
|
|
1021 (setq canna:attr-taishou
|
|
|
1022 (cdr (assq
|
|
|
1023 canna:attr-mode
|
|
|
1024 (assq 'taishou canna:attribute-alist))))))
|
|
|
1025 (setq canna:attr-select
|
|
|
1026 (if (listp canna-use-color)
|
|
|
1027 (car (cdr (cdr canna-use-color)))
|
|
|
1028 (setq canna:attr-select
|
|
|
1029 (cdr (assq canna:attr-mode
|
|
|
1030 (assq 'select canna:attribute-alist))))))
|
|
|
1031 ;;$B?'$E$1MQ(Bface$B$N:n@.(B
|
|
|
1032 (mapcar
|
|
|
1033 (function
|
|
|
1034 (lambda (face)
|
|
|
1035 (let* ((color (symbol-value
|
|
|
1036 (intern (concat "canna:" (symbol-name face)))))
|
|
|
1037 backp)
|
|
|
1038 (make-face face)
|
|
|
1039 (if (stringp color)
|
|
|
1040 (progn
|
|
|
1041 (setq backp (string-match "/" color))
|
|
|
1042 (set-face-foreground
|
|
|
1043 face (substring color 0 backp))
|
|
|
1044 (if backp
|
|
|
1045 (set-face-background
|
|
|
1046 face (substring color (1+ backp)))))
|
|
|
1047 (copy-face color face)))))
|
|
|
1048 '(attr-yomi attr-taishou attr-select))
|
|
|
1049 ))
|
|
|
1050 ;;$BG[?'@_Dj=*N;(B
|
|
|
1051
|
|
|
1052 ;; $B!X$+$s$J!Y%7%9%F%`$N=i4|2=(B
|
|
|
1053
|
|
|
1054 (setq init-val (canna:initialize))
|
|
|
1055
|
|
|
1056 ;; $B%-!<$N%P%$%s%G%#%s%0(B
|
|
|
1057
|
|
|
1058 (let ((ch 32))
|
|
|
1059 (while (< ch 127)
|
|
|
1060 (define-key global-map (make-string 1 ch) 'canna-self-insert-command)
|
|
|
1061 (setq ch (1+ ch)) ))
|
|
|
1062
|
|
207
|
1063 (cond
|
|
|
1064 ;; #### I'm just guessing that this should come before the
|
|
|
1065 ;; init-val setting
|
|
|
1066 ;; if registered with LEIM, no-op
|
|
|
1067 ((featurep 'canna-leim) t)
|
|
|
1068 ;; check to see if an X resource or the like is available in
|
|
|
1069 ;; init-val
|
|
|
1070 ((let ((keys (car init-val)) (ok nil))
|
|
70
|
1071 (while keys
|
|
|
1072 (cond ((< (car keys) 128)
|
|
|
1073 (global-set-key
|
|
|
1074 (make-string 1 (car keys))
|
|
|
1075 'canna-toggle-japanese-mode)
|
|
|
1076 (setq ok t) ))
|
|
|
1077 (setq keys (cdr keys))
|
|
|
1078 ) ok))
|
|
207
|
1079 ;; $B%G%U%)%k%H$N@_Dj(B
|
|
|
1080 ;; Since XEmacs provides canna-leim.el, we should leave this
|
|
|
1081 ;; as is.
|
|
|
1082 (t (global-set-key "\C-o" 'canna-toggle-japanese-mode)) )
|
|
70
|
1083
|
|
207
|
1084 ;; #### should these global bindings be conditional on LEIM?
|
|
|
1085 ;; LEIM doesn't use kanji key yet AFAIK, so leave them.
|
|
70
|
1086 (if (not (keymapp (global-key-binding "\e[")))
|
|
|
1087 (global-unset-key "\e[") )
|
|
|
1088 (global-set-key "\e[210z" 'canna-toggle-japanese-mode) ; XFER
|
|
|
1089 (define-key global-map [kanji] 'canna-toggle-japanese-mode)
|
|
|
1090 (if canna-do-keybind-for-functionkeys
|
|
|
1091 (progn
|
|
|
1092 (global-set-key "\e[28~" 'canna-extend-mode) ; HELP on EWS4800
|
|
|
1093 (global-set-key "\e[2~" 'canna-kigou-mode) ; INS on EWS4800
|
|
|
1094 (global-set-key "\e[11~" 'canna-kigou-mode)
|
|
|
1095 (global-set-key "\e[12~" 'canna-hex-mode)
|
|
|
1096 (global-set-key "\e[13~" 'canna-bushu-mode)
|
|
|
1097 (define-key global-map [help] 'canna-extend-mode)
|
|
|
1098 (define-key global-map [insert] 'canna-kigou-mode)
|
|
|
1099 (define-key global-map [f1] 'canna-kigou-mode)
|
|
|
1100 (define-key global-map [f2] 'canna-hex-mode)
|
|
|
1101 (define-key global-map [f3] 'canna-bushu-mode)
|
|
|
1102 ))
|
|
|
1103
|
|
|
1104 (if canna-use-space-key-as-henkan-region
|
|
|
1105 (progn
|
|
|
1106 (global-set-key "\C-@" 'canna-set-mark-command)
|
|
|
1107 ;; X Window $B$O(B C-@ $B$H(B C-SPC $B$r6hJL$9$k$N$G!"$3$l$,I,MW!#(B
|
|
|
1108 (global-set-key [?\C-\ ] 'canna-set-mark-command)
|
|
|
1109 (global-set-key " " 'canna-henkan-region-or-self-insert) ))
|
|
|
1110
|
|
|
1111 ;; $B%b!<%I9T$N:n@.(B
|
|
|
1112
|
|
|
1113 (canna:create-mode-line)
|
|
|
1114 (mode-line-canna-mode-update canna:*alpha-mode-string*)
|
|
|
1115
|
|
|
1116 ;; $B%7%9%F%`4X?t$N=q$-BX$((B
|
|
|
1117
|
|
|
1118 ; (fset 'abort-recursive-edit
|
|
|
1119 ; (symbol-function 'canna:abort-recursive-edit))
|
|
|
1120 ; (fset 'keyboard-quit
|
|
|
1121 ; (symbol-function 'canna:keyboard-quit))
|
|
|
1122
|
|
|
1123 )
|
|
|
1124
|
|
|
1125 ((fboundp 'canna-initialize)
|
|
|
1126 (beep)
|
|
|
1127 (with-output-to-temp-buffer "*canna-warning*"
|
|
|
1128 (princ "$B$3$N(B Mule $B$G$O(B new-canna $B$,;H$($^$;$s(B")
|
|
|
1129 (terpri)
|
|
|
1130 (print-help-return-message)) )
|
|
|
1131
|
|
|
1132 (t ; $B!X$+$s$J!Y%7%9%F%`$,;H$($J$+$C$?;~$N=hM}(B
|
|
|
1133 (beep)
|
|
|
1134 (with-output-to-temp-buffer "*canna-warning*"
|
|
|
1135 (princ "$B$3$N(B Mule $B$G$O(B canna $B$,;H$($^$;$s(B")
|
|
|
1136 (terpri)
|
|
|
1137 (print-help-return-message))
|
|
|
1138 ))
|
|
|
1139 (message "$B!X$+$s$J!Y$r=i4|2=$7$F$$$^$9(B....done")
|
|
|
1140 ) )
|
|
|
1141
|
|
|
1142 ;;;
|
|
|
1143 ;;; auto fill controll (from egg)
|
|
|
1144 ;;;
|
|
|
1145
|
|
|
1146 (defun canna:do-auto-fill ()
|
|
|
1147 (if (and auto-fill-function (not buffer-read-only)
|
|
|
1148 (> (current-column) fill-column))
|
|
|
1149 (let ((ocolumn (current-column)))
|
|
|
1150 (funcall auto-fill-function)
|
|
|
1151 (while (and (< fill-column (current-column))
|
|
|
1152 (< (current-column) ocolumn))
|
|
|
1153 (setq ocolumn (current-column))
|
|
|
1154 (funcall auto-fill-function)))))
|
|
|
1155
|
|
|
1156 (defun canna:output-warnings (mesg)
|
|
|
1157 (with-output-to-temp-buffer "*canna-warning*"
|
|
|
1158 (while mesg
|
|
|
1159 (princ (car mesg))
|
|
|
1160 (terpri)
|
|
|
1161 (setq mesg (cdr mesg)) )
|
|
|
1162 (print-help-return-message)))
|
|
|
1163
|
|
|
1164 (defun canna-undo (&optional arg)
|
|
|
1165 (interactive "*p")
|
|
|
1166 (if (and canna:*undo-text-yomi*
|
|
|
1167 (eq (current-buffer) (marker-buffer canna:*spos-undo-text*))
|
|
|
1168 ; (canna-without-newline canna:*spos-undo-text*
|
|
|
1169 ; canna:*epos-undo-text*)
|
|
|
1170 )
|
|
|
1171 (progn
|
|
|
1172 (message "$BFI$_$KLa$7$^$9!*(B")
|
|
|
1173 ; (switch-to-buffer (marker-buffer canna:*spos-undo-text*))
|
|
|
1174 (goto-char canna:*spos-undo-text*)
|
|
|
1175 (delete-region canna:*spos-undo-text*
|
|
|
1176 canna:*epos-undo-text*)
|
|
|
1177
|
|
|
1178 (if (null canna:*japanese-mode*)
|
|
|
1179 (progn
|
|
|
1180 (setq canna:*exit-japanese-mode* t) ))
|
|
|
1181 ; (canna-toggle-japanese-mode) ))
|
|
|
1182 (if (not canna:*fence-mode*)
|
|
|
1183 ;; $B%U%'%s%9%b!<%I$@$C$?$i$b$&0lEY%U%'%s%9%b!<%I$KF~$C$?$j$7(B
|
|
|
1184 ;; $B$J$$!#(B
|
|
|
1185 (canna:enter-canna-mode) )
|
|
|
1186 (canna:display-candidates
|
|
|
1187 (let ((texts (canna-store-yomi (car canna:*undo-text-yomi*)
|
|
|
1188 (cdr canna:*undo-text-yomi*) )) )
|
|
|
1189 (cond (canna-undo-hook
|
|
|
1190 (funcall canna-undo-hook))
|
|
|
1191 (t texts) )))
|
|
|
1192 (canna-abandon-undo-info)
|
|
|
1193 )
|
|
|
1194 (canna-abandon-undo-info)
|
|
|
1195 (undo arg) ))
|
|
|
1196
|
|
|
1197 (defun canna-abandon-undo-info ()
|
|
|
1198 (interactive)
|
|
|
1199 (setq canna:*undo-text-yomi* nil)
|
|
|
1200 (set-marker canna:*spos-undo-text* nil)
|
|
|
1201 (set-marker canna:*epos-undo-text* nil) )
|
|
|
1202
|
|
|
1203 (defun canna-henkan-region (start end)
|
|
|
1204 "Convert a text which is indicated by region into a kanji text."
|
|
|
1205 (interactive "*r")
|
|
|
1206 (if (null canna:*japanese-mode*)
|
|
|
1207 (progn
|
|
|
1208 (setq canna:*exit-japanese-mode* t) ))
|
|
|
1209 ; (canna-toggle-japanese-mode) ))
|
|
|
1210 (let ((res nil))
|
|
|
1211 (setq res (canna-store-yomi (buffer-substring start end)))
|
|
|
1212 (delete-region start end)
|
|
|
1213 (canna:enter-canna-mode)
|
|
|
1214 (if (fboundp 'canna-do-function)
|
|
|
1215 (setq res (canna-do-function canna-func-henkan)))
|
|
|
1216 (canna:display-candidates res) ))
|
|
|
1217
|
|
|
1218 ;;;
|
|
|
1219 ;;; $B%^!<%/%3%^%s%I!$(Bcanna-henkan-region-or-self-insert $B$G;H$&$+$b(B
|
|
|
1220 ;;;
|
|
|
1221
|
|
|
1222 (defun canna-set-mark-command (arg)
|
|
|
1223 "Besides setting mark, set mark as a HENKAN region if it is in\n\
|
|
|
1224 the japanese mode."
|
|
|
1225 (interactive "P")
|
|
|
1226 (set-mark-command arg)
|
|
|
1227 (if canna:*japanese-mode*
|
|
|
1228 (progn
|
|
|
1229 (setq canna:*use-region-as-henkan-region* t)
|
|
|
1230 (message "Mark set($BJQ49NN0h3+;O(B)") )))
|
|
|
1231
|
|
|
1232 (defun canna-henkan-region-or-self-insert (arg)
|
|
|
1233 "Do kana-to-kanji convert region if HENKAN region is defined,\n\
|
|
|
1234 self insert otherwise."
|
|
|
1235 (interactive "*p")
|
|
|
1236 (if (and canna:*use-region-as-henkan-region*
|
|
|
1237 ; (< (mark) (point))
|
|
|
1238 ; (not (save-excursion (beginning-of-line) (< (mark) (point)))) )
|
|
|
1239 (canna-without-newline (region-beginning) (region-end)))
|
|
|
1240 (progn
|
|
|
1241 (setq canna:*use-region-as-henkan-region* nil)
|
|
|
1242 (canna-henkan-region (region-beginning) (region-end)))
|
|
|
1243 (canna-self-insert-command arg) ))
|
|
|
1244
|
|
|
1245 ;;
|
|
|
1246 ;; for C-mode
|
|
|
1247 ;;
|
|
|
1248
|
|
|
1249 (defun canna-electric-c-terminator (arg)
|
|
|
1250 (interactive "P")
|
|
|
1251 (if canna:*japanese-mode*
|
|
|
1252 (canna-self-insert-command arg)
|
|
|
1253 (electric-c-terminator arg) ))
|
|
|
1254
|
|
|
1255 (defun canna-electric-c-semi (arg)
|
|
|
1256 (interactive "P")
|
|
|
1257 (if canna:*japanese-mode*
|
|
|
1258 (canna-self-insert-command arg)
|
|
|
1259 (electric-c-semi arg) ))
|
|
|
1260
|
|
|
1261 (defun canna-electric-c-brace (arg)
|
|
|
1262 (interactive "P")
|
|
|
1263 (if canna:*japanese-mode*
|
|
|
1264 (canna-self-insert-command arg)
|
|
|
1265 (electric-c-brace arg) ))
|
|
|
1266
|
|
|
1267 (defun canna-c-mode-hook ()
|
|
|
1268 (define-key c-mode-map "{" 'canna-electric-c-brace)
|
|
|
1269 (define-key c-mode-map "}" 'canna-electric-c-brace)
|
|
|
1270 (define-key c-mode-map ";" 'canna-electric-c-semi)
|
|
|
1271 (define-key c-mode-map ":" 'canna-electric-c-terminator) )
|
|
|
1272
|
|
|
1273 (defun canna-set-fence-mode-format (fence sep underline)
|
|
|
1274 (setq canna-with-fences fence)
|
|
|
1275 (canna-set-bunsetsu-kugiri sep)
|
|
|
1276 (setq canna-underline underline)
|
|
|
1277 )
|
|
|
1278
|
|
|
1279 ;; $B%j!<%8%g%s$K$"$k%m!<%^;z$r!X$+$s$J!Y$K?)$o$9!#(B
|
|
|
1280 ;; $B7k2L$H$7$F!"!X$+$s$J!Y$NFI$_%b!<%I$K$J$k!#(B
|
|
|
1281 ;; $B%j!<%8%g%s$KB8:_$7$F$$$k6uGrJ8;z$H@)8fJ8;z$O<N$F$i$l$k!#(B
|
|
|
1282
|
|
|
1283 (defun canna-rk-region (start end)
|
|
|
1284 "Convert region into kana."
|
|
|
1285 (interactive "*r")
|
|
|
1286 (let ((str nil) (len 0) (i 0) (res 0))
|
|
|
1287 (setq str (buffer-substring start end))
|
|
|
1288 (setq len (length str))
|
|
|
1289 (while (< i len)
|
|
|
1290 (let ((ch (elt str i)))
|
|
|
1291 (if (> ch ? )
|
|
|
1292 (setq res (canna-do-function canna-func-functional-insert ch)) ))
|
|
|
1293 (setq i (1+ i)) )
|
|
|
1294 res))
|
|
|
1295
|
|
|
1296 (defun canna-rk-trans-region (start end)
|
|
|
1297 "Insert alpha-numeric string as it is sent from keyboard."
|
|
|
1298 (interactive "*r")
|
|
|
1299 (let ((res))
|
|
|
1300 (setq res (canna-rk-region start end))
|
|
|
1301 (delete-region start end)
|
|
|
1302 (if (null canna:*japanese-mode*)
|
|
|
1303 (progn
|
|
|
1304 (setq canna:*exit-japanese-mode* t) ))
|
|
|
1305 (setq res (canna-do-function canna-func-henkan))
|
|
|
1306 (canna:enter-canna-mode)
|
|
|
1307 (canna:display-candidates res) ))
|
|
|
1308
|
|
|
1309 ;; $B%+!<%=%k$N:8$K$"$k(B arg $B%o!<%I$N%m!<%^;z$r!X$+$s$J!Y$K?)$o$9!#(B
|
|
|
1310
|
|
|
1311 (defun canna-rk-trans (arg)
|
|
|
1312 (interactive "*p")
|
|
|
1313 (let ((po (point)))
|
|
|
1314 (skip-chars-backward "-a-zA-Z.,?!~")
|
|
|
1315 (if (not (eq (point) po))
|
|
|
1316 (canna-rk-trans-region (point) po) )))
|
|
|
1317
|
|
|
1318 (defun canna-henkan-kakutei-and-self-insert (arg)
|
|
|
1319 (interactive "*p")
|
|
|
1320 (if canna:*japanese-mode*
|
|
|
1321 (canna-functional-insert-command arg)
|
|
|
1322 (progn
|
|
|
1323 (setq unread-command-events (list last-command-event))
|
|
|
1324 (canna-kakutei-to-basic-stat)) ))
|
|
|
1325
|
|
|
1326 (defun canna-kakutei-to-basic-stat ()
|
|
|
1327 (let ((res 0)
|
|
|
1328 (kakutei canna-henkan-string))
|
|
|
1329 (while (not canna-empty-info)
|
|
|
1330 ; (setq res (canna-key-proc ?\C-m)))
|
|
|
1331 (setq res (canna-do-function canna-func-kakutei)))
|
|
|
1332 (setq canna-kakutei-string kakutei)
|
|
|
1333 (canna:display-candidates (length canna-kakutei-string))
|
|
|
1334 (if (not canna:*japanese-mode*)
|
|
|
1335 (mode-line-canna-mode-update canna:*alpha-mode-string*))
|
|
|
1336 ))
|
|
|
1337
|
|
|
1338 (defun canna-minibuffer-henkan-kakutei-and-self-insert (arg)
|
|
|
1339 (interactive "p")
|
|
|
1340 (set-window-buffer (minibuffer-window) canna:*saved-minibuffer*)
|
|
|
1341 (select-window canna:*previous-window*)
|
|
|
1342 (if canna:*japanese-mode*
|
|
|
1343 (canna:functional-insert-command2 last-command-event arg)
|
|
|
1344 (progn
|
|
|
1345 (setq unread-command-events (list last-command-event))
|
|
|
1346 (canna-kakutei-to-basic-stat)) ))
|
|
|
1347
|
|
|
1348 (defun canna-setup-for-being-boiled ()
|
|
|
1349 (let ((ch (1+ ? )))
|
|
|
1350 (while (< ch 127)
|
|
|
1351 (define-key canna-mode-map (make-string 1 ch) 'canna-henkan-kakutei-and-self-insert)
|
|
|
1352 (define-key canna-minibuffer-mode-map (make-string 1 ch) 'canna-minibuffer-henkan-kakutei-and-self-insert)
|
|
|
1353 (setq ch (1+ ch)))))
|
|
|
1354
|
|
|
1355 (defvar rK-trans-key "\C-j" "for `boil' only")
|
|
|
1356 (make-variable-buffer-local 'rK-trans-key)
|
|
|
1357
|
|
|
1358 (defun canna-boil ()
|
|
|
1359 "`canna-boil' cooks `canna' as if `boil' does for `egg'."
|
|
|
1360 (interactive)
|
|
|
1361 (canna-setup-for-being-boiled)
|
|
|
1362 (local-set-key rK-trans-key 'canna-rk-trans)
|
|
|
1363 (message "boiled"))
|
|
|
1364
|
|
|
1365 ;;
|
|
|
1366 ;; $B?'$E$1$N$?$a$N4X?t(B
|
|
|
1367 ;;
|
|
|
1368 (defun canna:yomi-attr-on (start end)
|
|
|
1369 (if (overlayp canna:*yomi-overlay*)
|
|
|
1370 (move-overlay canna:*yomi-overlay* start end)
|
|
120
|
1371 (overlay-put (setq canna:*yomi-overlay* (make-overlay start end nil nil t))
|
|
70
|
1372 'face
|
|
|
1373 (if canna:color-p 'attr-yomi 'underline))
|
|
|
1374 )
|
|
|
1375 )
|
|
|
1376
|
|
|
1377 (defun canna:yomi-attr-off (start end);
|
|
|
1378 (and (overlayp canna:*yomi-overlay*)
|
|
|
1379 (delete-overlay canna:*yomi-overlay*)
|
|
|
1380 )
|
|
|
1381 )
|
|
|
1382
|
|
|
1383 (defun canna:henkan-attr-on (start end)
|
|
|
1384 (if (overlayp canna:*henkan-overlay*)
|
|
|
1385 (move-overlay canna:*henkan-overlay* start end)
|
|
120
|
1386 (overlay-put (setq canna:*henkan-overlay*
|
|
|
1387 (make-overlay start end nil nil t))
|
|
70
|
1388 'face
|
|
|
1389 (if canna:color-p 'attr-taishou 'region))
|
|
|
1390 )
|
|
|
1391 )
|
|
|
1392
|
|
|
1393 (defun canna:henkan-attr-off (start end)
|
|
|
1394 (and (overlayp canna:*henkan-overlay*)
|
|
|
1395 (delete-overlay canna:*henkan-overlay*)
|
|
|
1396 )
|
|
|
1397 )
|
|
|
1398
|
|
|
1399 (defun canna:select-attr-on (start end)
|
|
|
1400 (if (overlayp canna:*select-overlay*)
|
|
|
1401 (move-overlay canna:*select-overlay* start end)
|
|
120
|
1402 (overlay-put (setq canna:*select-overlay*
|
|
|
1403 (make-overlay start end nil nil t))
|
|
70
|
1404 'face
|
|
|
1405 'attr-select))
|
|
|
1406 )
|
|
|
1407
|
|
|
1408 (defun canna:select-attr-off (start end)
|
|
|
1409 (and (overlayp canna:*select-overlay*)
|
|
|
1410 (delete-overlay canna:*select-overlay*)
|
|
|
1411 )
|
|
|
1412 )
|
|
|
1413
|
|
120
|
1414
|
|
70
|
1415 (provide 'canna)
|
|
120
|
1416
|
|
|
1417 ;;; canna.el ends here
|
