sekka 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/emacs/sekka.el ADDED
@@ -0,0 +1,1069 @@
1
+ ;; -*- coding: iso-2022-jp -*-
2
+ ;;
3
+ ;; "sekka.el" is a client for Sekka server
4
+ ;;
5
+ ;; Copyright (C) 2010 Kiyoka Nishiyama
6
+ ;; This program was derived from sumibi.el and yc.el-4.0.13(auther: knak)
7
+ ;;
8
+ ;;
9
+ ;; This file is part of Sekka
10
+ ;;
11
+ ;; Sekka is free software; you can redistribute it and/or modify
12
+ ;; it under the terms of the GNU General Public License as published by
13
+ ;; the Free Software Foundation; either version 2, or (at your option)
14
+ ;; any later version.
15
+ ;;
16
+ ;; Sekka is distributed in the hope that it will be useful,
17
+ ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18
+ ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
+ ;; GNU General Public License for more details.
20
+ ;;
21
+ ;; You should have received a copy of the GNU General Public License
22
+ ;; along with Sekka; see the file COPYING.
23
+ ;;
24
+
25
+ ;;; Code:
26
+ (require 'cl)
27
+ (require 'http-get)
28
+
29
+ ;;;
30
+ ;;;
31
+ ;;; customize variables
32
+ ;;;
33
+ (defgroup sekka nil
34
+ "Sekka client."
35
+ :group 'input-method
36
+ :group 'Japanese)
37
+
38
+ (defcustom sekka-server-url "http://localhost:12929/"
39
+ "Sekka$B%5!<%P!<$N(BURL$B$r;XDj$9$k!#(B"
40
+ :type 'string
41
+ :group 'sekka)
42
+
43
+ (defcustom sekka-server-timeout 10
44
+ "Sekka$B%5!<%P!<$HDL?.$9$k;~$N%?%$%`%"%&%H$r;XDj$9$k!#(B($BIC?t(B)"
45
+ :type 'integer
46
+ :group 'sekka)
47
+
48
+ (defcustom sekka-stop-chars "(){}<> "
49
+ "*$B4A;zJQ49J8;zNs$r<h$j9~$`;~$KJQ49HO0O$K4^$a$J$$J8;z$r@_Dj$9$k(B"
50
+ :type 'string
51
+ :group 'sekka)
52
+
53
+ (defcustom sekka-curl "curl"
54
+ "curl$B%3%^%s%I$N@dBP%Q%9$r@_Dj$9$k(B"
55
+ :type 'string
56
+ :group 'sekka)
57
+
58
+ (defcustom sekka-use-viper nil
59
+ "*Non-nil $B$G$"$l$P!"(BVIPER $B$KBP1~$9$k(B"
60
+ :type 'boolean
61
+ :group 'sekka)
62
+
63
+ (defcustom sekka-realtime-guide-running-seconds 30
64
+ "$B%j%"%k%?%$%`%,%$%II=<($N7QB3;~4V(B($BIC?t(B)$B!&%<%m$G%,%$%II=<(5!G=$,L58z$K$J$k(B"
65
+ :type 'integer
66
+ :group 'sekka)
67
+
68
+ (defcustom sekka-realtime-guide-limit-lines 5
69
+ "$B:G8e$KJQ49$7$?9T$+$i(B N $B9TN%$l$?$i%j%"%k%?%$%`%,%$%II=<($,;_$^$k(B"
70
+ :type 'integer
71
+ :group 'sekka)
72
+
73
+ (defcustom sekka-realtime-guide-interval 0.2
74
+ "$B%j%"%k%?%$%`%,%$%II=<($r99?7$9$k;~4V4V3V(B"
75
+ :type 'integer
76
+ :group 'sekka)
77
+
78
+ (defcustom sekka-roman-method "normal"
79
+ "$B%m!<%^;zF~NOJ}<0$H$7$F!$(Bnormal($BDL>o%m!<%^;z(B)$B$+!"(BAZIK($B3HD%%m!<%^;z(B)$B$N$I$A$i$N2r<a$rM%@h$9$k$+(B"
80
+ :type '(choice (const :tag "normal" "normal")
81
+ (const :tag "AZIK" "azik" ))
82
+ :group 'sekka)
83
+
84
+
85
+ (defface sekka-guide-face
86
+ '((((class color) (background light)) (:background "#E0E0E0" :foreground "#F03030")))
87
+ "$B%j%"%k%?%$%`%,%$%I$N%U%'%$%9(B($BAu>~!"?'$J$I$N;XDj(B)"
88
+ :group 'sekka)
89
+
90
+
91
+ (defvar sekka-sticky-shift nil "*Non-nil $B$G$"$l$P!"(BSticky-Shift$B$rM-8z$K$9$k(B")
92
+ (defvar sekka-mode nil "$B4A;zJQ49%H%0%kJQ?t(B")
93
+ (defvar sekka-mode-line-string " Sekka")
94
+ (defvar sekka-select-mode nil "$B8uJdA*Br%b!<%IJQ?t(B")
95
+ (or (assq 'sekka-mode minor-mode-alist)
96
+ (setq minor-mode-alist (cons
97
+ '(sekka-mode sekka-mode-line-string)
98
+ minor-mode-alist)))
99
+
100
+
101
+ ;; $B%m!<%^;z4A;zJQ49;~!"BP>]$H$9$k%m!<%^;z$r@_Dj$9$k$?$a$NJQ?t(B
102
+ (defvar sekka-skip-chars "a-zA-Z0-9.,@:`\\-+!\\[\\]?;")
103
+ (defvar sekka-mode-map (make-sparse-keymap) "$B4A;zJQ49%H%0%k%^%C%W(B")
104
+ (defvar sekka-select-mode-map (make-sparse-keymap) "$B8uJdA*Br%b!<%I%^%C%W(B")
105
+ (defvar sekka-rK-trans-key "\C-j"
106
+ "*$B4A;zJQ49%-!<$r@_Dj$9$k(B")
107
+ (or (assq 'sekka-mode minor-mode-map-alist)
108
+ (setq minor-mode-map-alist
109
+ (append (list (cons 'sekka-mode sekka-mode-map)
110
+ (cons 'sekka-select-mode sekka-select-mode-map))
111
+ minor-mode-map-alist)))
112
+
113
+ ;;;
114
+ ;;; hooks
115
+ ;;;
116
+ (defvar sekka-mode-hook nil)
117
+ (defvar sekka-select-mode-hook nil)
118
+ (defvar sekka-select-mode-end-hook nil)
119
+
120
+ (defconst sekka-login-name (user-login-name))
121
+
122
+ (defconst sekka-kind-index 3)
123
+ (defconst sekka-id-index 4)
124
+
125
+ ;;--- $B%G%P%C%0%a%C%;!<%8=PNO(B
126
+ (defvar sekka-psudo-server nil) ; $B%/%i%$%"%s%HC1BN$G2>A[E*$K%5!<%P!<$K@\B3$7$F$$$k$h$&$K$7$F%F%9%H$9$k%b!<%I(B
127
+
128
+ ;;--- $B%G%P%C%0%a%C%;!<%8=PNO(B
129
+ (defvar sekka-debug nil) ; $B%G%P%C%0%U%i%0(B
130
+ (defun sekka-debug-print (string)
131
+ (if sekka-debug
132
+ (let
133
+ ((buffer (get-buffer-create "*sekka-debug*")))
134
+ (with-current-buffer buffer
135
+ (goto-char (point-max))
136
+ (insert string)))))
137
+
138
+
139
+ ;;; sekka basic output
140
+ (defvar sekka-fence-start nil) ; fence $B;OC<0LCV(B
141
+ (defvar sekka-fence-end nil) ; fence $B=*C<0LCV(B
142
+ (defvar sekka-henkan-separeter " ") ; fence mode separeter
143
+ (defvar sekka-henkan-buffer nil) ; $BI=<(MQ%P%C%U%!(B
144
+ (defvar sekka-henkan-length nil) ; $BI=<(MQ%P%C%U%!D9(B
145
+ (defvar sekka-henkan-revpos nil) ; $BJ8@a;OC<0LCV(B
146
+ (defvar sekka-henkan-revlen nil) ; $BJ8@aD9(B
147
+
148
+ ;;; sekka basic local
149
+ (defvar sekka-cand-cur 0) ; $B%+%l%s%H8uJdHV9f(B
150
+ (defvar sekka-cand-cur-backup 0) ; $B%+%l%s%H8uJdHV9f(B(UNDO$BMQ$KB`Hr$9$kJQ?t(B)
151
+ (defvar sekka-cand-len nil) ; $B8uJd?t(B
152
+ (defvar sekka-last-fix "") ; $B:G8e$K3NDj$7$?J8;zNs(B
153
+ (defvar sekka-henkan-kouho-list nil) ; $BJQ497k2L%j%9%H(B($B%5!<%P$+$i5"$C$F$-$?%G!<%?$=$N$b$N(B)
154
+ (defvar sekka-markers '()) ; $BJ8@a3+;O!"=*N;0LCV$N(Bpair: $B<!$N$h$&$J7A<0(B ( 1 . 2 )
155
+ (defvar sekka-timer nil) ; $B%$%s%?!<%P%k%?%$%^!<7?JQ?t(B
156
+ (defvar sekka-timer-rest 0) ; $B$"$H2?2s8F=P$5$l$?$i!"%$%s%?!<%P%k%?%$%^$N8F=P$r;_$a$k$+(B
157
+ (defvar sekka-last-lineno 0) ; $B:G8e$KJQ49$r<B9T$7$?9THV9f(B
158
+ (defvar sekka-guide-overlay nil) ; $B%j%"%k%?%$%`%,%$%I$K;HMQ$9$k%*!<%P!<%l%$(B
159
+ (defvar sekka-last-request-time 0) ; Sekka$B%5!<%P!<$K%j%/%(%9%H$7$?:G8e$N;~9o(B($BC10L$OIC(B)
160
+ (defvar sekka-guide-lastquery "") ; Sekka$B%5!<%P!<$K%j%/%(%9%H$7$?:G8e$N%/%(%jJ8;zNs(B
161
+ (defvar sekka-guide-lastresult '()) ; Sekka$B%5!<%P!<$K%j%/%(%9%H$7$?:G8e$N%/%(%jJ8;zNs(B
162
+
163
+
164
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
165
+ ;; Skicky-shift
166
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
167
+ (defvar sticky-key ";")
168
+ (defvar sticky-list
169
+ '(("a" . "A")("b" . "B")("c" . "C")("d" . "D")("e" . "E")("f" . "F")("g" . "G")
170
+ ("h" . "H")("i" . "I")("j" . "J")("k" . "K")("l" . "L")("m" . "M")("n" . "N")
171
+ ("o" . "O")("p" . "P")("q" . "Q")("r" . "R")("s" . "S")("t" . "T")("u" . "U")
172
+ ("v" . "V")("w" . "W")("x" . "X")("y" . "Y")("z" . "Z")
173
+ ("1" . "!")("2" . "\"")("3" . "#")("4" . "$")("5" . "%")("6" . "&")("7" . "'")
174
+ ("8" . "(")("9" . ")")
175
+ ("`" . "@")("[" . "{")("]" . "}")("-" . "=")("^" . "~")("\\" . "|")("." . ">")
176
+ ("/" . "?")(";" . ";")(":" . "*")("@" . "`")
177
+ ("\C-h" . "")
178
+ ))
179
+ (defvar sticky-map (make-sparse-keymap))
180
+
181
+
182
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
183
+ ;; $BI=<(7O4X?t72(B
184
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
185
+ (defvar sekka-use-fence t)
186
+ (defvar sekka-use-color nil)
187
+
188
+ (defvar sekka-init nil)
189
+
190
+ ;;
191
+ ;; $B=i4|2=(B
192
+ ;;
193
+ (defun sekka-init ()
194
+ ;; $B:G=i$N(B n $B7o$N%j%9%H$r<hF@$9$k(B
195
+ (defun sekka-take (arg-list n)
196
+ (let ((lst '()))
197
+ (dotimes (i n (reverse lst))
198
+ (let ((item (nth i arg-list)))
199
+ (when item
200
+ (push item lst))))))
201
+
202
+ (when (not sekka-init)
203
+ ;; $B%f!<%6!<8lWC$N%m!<%I(B + $B%5!<%P!<$X$NEPO?(B
204
+ (sekka-register-userdict-internal)
205
+
206
+ ;; Emacs$B=*N;;~$N=hM}(B
207
+ (add-hook 'kill-emacs-hook
208
+ (lambda ()
209
+ ;; $B2?$b$9$k$3$H$OL5$$(B
210
+ t))
211
+ ;; $B=i4|2=40N;(B
212
+ (setq sekka-init t)))
213
+
214
+
215
+ (defun sekka-construct-curl-argstr (arg-alist)
216
+ (apply 'concat
217
+ (mapcar
218
+ (lambda (x)
219
+ (format "--data '%s=%s' " (car x)
220
+ (if (stringp (cdr x))
221
+ (http-url-encode (cdr x) 'utf-8)
222
+ (cdr x))))
223
+ arg-alist)))
224
+
225
+ ;; test-code
226
+ (when nil
227
+ (sekka-construct-curl-argstr
228
+ '(
229
+ ("yomi" . "kanji")
230
+ ("limit" . 2)
231
+ ("method" . "normal")
232
+ )))
233
+
234
+ ;;
235
+ ;; $B%m!<%^;z$G=q$+$l$?J8>O$r(BSekka$B%5!<%P!<$r;H$C$FJQ49$9$k(B
236
+ ;;
237
+ ;; arg-alist$B$N0z?t$N7A<0(B
238
+ ;; $BNc(B:
239
+ ;; '(
240
+ ;; ("yomi" . "kanji")
241
+ ;; ("limit" . 2)
242
+ ;; ("method" . "normal")
243
+ ;; )
244
+ (defun sekka-rest-request (func-name arg-alist)
245
+ (if sekka-psudo-server
246
+ ;; $B%/%i%$%"%s%HC1BN$G2>A[E*$K%5!<%P!<$K@\B3$7$F$$$k$h$&$K$7$F%F%9%H$9$k%b!<%I(B
247
+ "((\"$BJQ49(B\" nil \"$B$X$s$+$s(B\" j 0) (\"$BJQ2=(B\" nil \"$B$X$s$+(B\" j 1) (\"$B%X%s%+%s(B\" nil \"$B$X$s$+$s(B\" k 2) (\"$B$X$s$+$s(B\" nil \"$B$X$s$+$s(B\" h 3))"
248
+ ;;"((\"$BJQ49(B\" nil \"$B$X$s$+$s(B\" j 0) (\"$BJQ2=(B\" nil \"$B$X$s$+(B\" j 1))"
249
+ ;; $B<B:]$N%5!<%P$K@\B3$9$k(B
250
+ (let ((command
251
+ (concat
252
+ sekka-curl " --silent --show-error "
253
+ (format " --max-time %d " sekka-server-timeout)
254
+ " --insecure "
255
+ " --header 'Content-Type: application/x-www-form-urlencoded' "
256
+ (format "%s%s " sekka-server-url func-name)
257
+ (sekka-construct-curl-argstr (cons
258
+ '("format" . "sexp")
259
+ arg-alist))
260
+ (format "--data 'userid=%s' " sekka-login-name))))
261
+
262
+ (sekka-debug-print (format "curl-command :%s\n" command))
263
+
264
+ (let (
265
+ (result
266
+ (shell-command-to-string
267
+ command)))
268
+
269
+ (sekka-debug-print (format "curl-result-sexp :%s\n" result))
270
+ result))))
271
+
272
+ ;;
273
+ ;; $B8=:_;~9o$r(BUNIX$B%?%$%`$rJV$9(B($BC10L$OIC(B)
274
+ ;;
275
+ (defun sekka-current-unixtime ()
276
+ (let (
277
+ (_ (current-time)))
278
+ (+
279
+ (* (car _)
280
+ 65536)
281
+ (cadr _))))
282
+
283
+
284
+ ;;
285
+ ;; $B%m!<%^;z$G=q$+$l$?J8>O$r(BSekka$B%5!<%P!<$r;H$C$FJQ49$9$k(B
286
+ ;;
287
+ (defun sekka-henkan-request (yomi limit)
288
+ (sekka-debug-print (format "henkan-input :[%s]\n" yomi))
289
+
290
+ ;;(message "Requesting to sekka server...")
291
+
292
+ (let (
293
+ (result (sekka-rest-request "henkan" `((yomi . ,yomi)
294
+ (limit . ,limit)
295
+ (method . ,sekka-roman-method)))))
296
+ (sekka-debug-print (format "henkan-result:%S\n" result))
297
+ (if (eq (string-to-char result) ?\( )
298
+ (progn
299
+ (message nil)
300
+ (condition-case err
301
+ (read result)
302
+ (end-of-file
303
+ (progn
304
+ (message "Parse error for parsing result of Sekka Server.")
305
+ nil))))
306
+ (progn
307
+ (message result)
308
+ nil))))
309
+
310
+ ;;
311
+ ;; $B3NDj$7$?C18l$r%5!<%P!<$KEAC#$9$k(B
312
+ ;;
313
+ (defun sekka-kakutei-request (key tango)
314
+ (sekka-debug-print (format "henkan-kakutei key=[%s] tango=[%s]\n" key tango))
315
+
316
+ (message "Requesting to sekka server...")
317
+
318
+ (let ((result (sekka-rest-request "kakutei" `(
319
+ (key . ,key)
320
+ (tango . ,tango)))))
321
+ (sekka-debug-print (format "kakutei-result:%S\n" result))
322
+ (message result)
323
+ t))
324
+
325
+ ;;
326
+ ;; $B%f!<%6!<8lWC$r%5!<%P!<$K:FEYEPO?$9$k!#(B
327
+ ;;
328
+ (defun sekka-register-userdict (&optional arg)
329
+ "$B%f!<%6!<<-=q$r%5!<%P!<$K:FEY%"%C%W%m!<%I$9$k(B"
330
+ (interactive "P")
331
+ (sekka-register-userdict-internal))
332
+
333
+
334
+ ;;
335
+ ;; $B%f!<%6!<8lWC$r%5!<%P!<$KEPO?$9$k!#(B
336
+ ;;
337
+ (defun sekka-register-userdict-internal ()
338
+ (let ((str (sekka-get-jisyo-str "~/.sekka-jisyo")))
339
+ (when str
340
+ (message "Requesting to sekka server...")
341
+ (sekka-debug-print (format "register [%s]\n" str))
342
+ (let ((result (sekka-rest-request "register" `((dict . ,str)))))
343
+ (sekka-debug-print (format "register-result:%S\n" result))
344
+ (message result)
345
+ t))))
346
+
347
+
348
+ (defun sekka-get-jisyo-str (file &optional nomsg)
349
+ "FILE $B$r3+$$$F(B SKK $B<-=q%P%C%U%!$r:n$j!"%P%C%U%!$rJV$9!#(B
350
+ $B%*%W%7%g%s0z?t$N(B NOMSG $B$r;XDj$9$k$H%U%!%$%kFI$_9~$_$N:]$N%a%C%;!<%8$rI=<($7$J(B
351
+ $B$$!#(B"
352
+ (when file
353
+ (let* ((file (or (car-safe file)
354
+ file))
355
+ (file (expand-file-name file)))
356
+ (if (not (file-exists-p file))
357
+ (progn
358
+ (message (format "SKK $B<-=q(B %s $B$,B8:_$7$^$;$s(B..." file))
359
+ nil)
360
+ (let ((str "")
361
+ (buf-name (file-name-nondirectory file)))
362
+ (save-excursion
363
+ (find-file-read-only file)
364
+ (setq str (with-current-buffer (get-buffer buf-name)
365
+ (buffer-substring-no-properties (point-min) (point-max))))
366
+ (message (format "SKK $B<-=q(B %s $B$r3+$$$F$$$^$9(B...$B40N;!*(B" (file-name-nondirectory file)))
367
+ (kill-buffer-if-not-modified (get-buffer buf-name)))
368
+ str)))))
369
+
370
+ ;;(sekka-get-jisyo-str "~/.sekka-jisyo")
371
+
372
+
373
+ ;; $B%]!<%?%V%kJ8;zNsCV49(B( Emacs$B$H(BXEmacs$B$NN>J}$GF0$/(B )
374
+ (defun sekka-replace-regexp-in-string (regexp replace str)
375
+ (cond ((featurep 'xemacs)
376
+ (replace-in-string str regexp replace))
377
+ (t
378
+ (replace-regexp-in-string regexp replace str))))
379
+
380
+
381
+ ;; $B%j!<%8%g%s$r%m!<%^;z4A;zJQ49$9$k4X?t(B
382
+ (defun sekka-henkan-region (b e)
383
+ "$B;XDj$5$l$?(B region $B$r4A;zJQ49$9$k(B"
384
+ (sekka-init)
385
+ (when (/= b e)
386
+ (let* (
387
+ (yomi (buffer-substring-no-properties b e))
388
+ (henkan-list (sekka-henkan-request yomi 0)))
389
+
390
+ (if henkan-list
391
+ (condition-case err
392
+ (progn
393
+ (setq
394
+ ;; $BJQ497k2L$NJ];}(B
395
+ sekka-henkan-kouho-list henkan-list
396
+ ;; $BJ8@aA*Br=i4|2=(B
397
+ sekka-cand-cur 0
398
+ ;;
399
+ sekka-cand-len (length henkan-list))
400
+
401
+ (sekka-debug-print (format "sekka-henkan-kouho-list:%s \n" sekka-henkan-kouho-list))
402
+ (sekka-debug-print (format "sekka-cand-cur:%s \n" sekka-cand-cur))
403
+ (sekka-debug-print (format "sekka-cand-len:%s \n" sekka-cand-len))
404
+ ;;
405
+ t)
406
+ (sekka-trap-server-down
407
+ (beep)
408
+ (message (error-message-string err))
409
+ (setq sekka-select-mode nil))
410
+ (run-hooks 'sekka-select-mode-end-hook))
411
+ nil))))
412
+
413
+
414
+ ;; $B%+!<%=%kA0$NJ8;z<o$rJV5Q$9$k4X?t(B
415
+ (eval-and-compile
416
+ (if (>= emacs-major-version 20)
417
+ (progn
418
+ (defalias 'sekka-char-charset (symbol-function 'char-charset))
419
+ (when (and (boundp 'byte-compile-depth)
420
+ (not (fboundp 'char-category)))
421
+ (defalias 'char-category nil))) ; for byte compiler
422
+ (defun sekka-char-charset (ch)
423
+ (cond ((equal (char-category ch) "a") 'ascii)
424
+ ((equal (char-category ch) "k") 'katakana-jisx0201)
425
+ ((string-match "[SAHK]j" (char-category ch)) 'japanese-jisx0208)
426
+ (t nil) )) ))
427
+
428
+
429
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
430
+ ;; undo $B>pJs$N@)8f(B
431
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
432
+ ;; undo buffer $BB`HrMQJQ?t(B
433
+ (defvar sekka-buffer-undo-list nil)
434
+ (make-variable-buffer-local 'sekka-buffer-undo-list)
435
+ (defvar sekka-buffer-modified-p nil)
436
+ (make-variable-buffer-local 'sekka-buffer-modified-p)
437
+
438
+ (defvar sekka-blink-cursor nil)
439
+ (defvar sekka-cursor-type nil)
440
+ ;; undo buffer $B$rB`Hr$7!"(Bundo $B>pJs$NC_@Q$rDd;_$9$k4X?t(B
441
+ (defun sekka-disable-undo ()
442
+ (when (not (eq buffer-undo-list t))
443
+ (setq sekka-buffer-undo-list buffer-undo-list)
444
+ (setq sekka-buffer-modified-p (buffer-modified-p))
445
+ (setq buffer-undo-list t)))
446
+
447
+ ;; $BB`Hr$7$?(B undo buffer $B$rI|5"$7!"(Bundo $B>pJs$NC_@Q$r:F3+$9$k4X?t(B
448
+ (defun sekka-enable-undo ()
449
+ (when (not sekka-buffer-modified-p) (set-buffer-modified-p nil))
450
+ (when sekka-buffer-undo-list
451
+ (setq buffer-undo-list sekka-buffer-undo-list)))
452
+
453
+
454
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
455
+ ;; $B8=:_$NJQ49%(%j%"$NI=<($r9T$&(B
456
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
457
+ (defun sekka-get-display-string ()
458
+ ;; $BJQ497k2LJ8;zNs$rJV$9!#(B
459
+ (let* ((kouho (nth sekka-cand-cur sekka-henkan-kouho-list))
460
+ (_ (sekka-debug-print (format "sekka-cand-cur=%s\n" sekka-cand-cur)))
461
+ (_ (sekka-debug-print (format "kouho=%s\n" kouho)))
462
+ (word (car kouho))
463
+ (annotation (cadr kouho)))
464
+ (sekka-debug-print (format "word:[%d] %s(%s)\n" sekka-cand-cur word annotation))
465
+ word))
466
+
467
+ (defun sekka-display-function (b e select-mode)
468
+ (setq sekka-henkan-separeter (if sekka-use-fence " " ""))
469
+ (when sekka-henkan-kouho-list
470
+ ;; UNDO$BM^@)3+;O(B
471
+ (sekka-disable-undo)
472
+
473
+ (delete-region b e)
474
+
475
+ ;; $B%j%9%H=i4|2=(B
476
+ (setq sekka-markers '())
477
+
478
+ (setq sekka-last-fix "")
479
+
480
+ ;; $BJQ49$7$?(Bpoint$B$NJ];}(B
481
+ (setq sekka-fence-start (point-marker))
482
+ (when select-mode (insert "|"))
483
+
484
+ (let* (
485
+ (start (point-marker))
486
+ (_cur sekka-cand-cur)
487
+ (_len sekka-cand-len)
488
+ (insert-word (sekka-get-display-string)))
489
+ (progn
490
+ (insert insert-word)
491
+ (message (format "[%s] candidate (%d/%d)" insert-word (+ _cur 1) _len))
492
+ (let* ((end (point-marker))
493
+ (ov (make-overlay start end)))
494
+
495
+ ;; $B3NDjJ8;zNs$N:n@.(B
496
+ (setq sekka-last-fix insert-word)
497
+
498
+ ;; $BA*BrCf$N>l=j$rAu>~$9$k!#(B
499
+ (overlay-put ov 'face 'default)
500
+ (when select-mode
501
+ (overlay-put ov 'face 'highlight))
502
+ (setq sekka-markers (cons start end))
503
+ (sekka-debug-print (format "insert:[%s] point:%d-%d\n" insert-word (marker-position start) (marker-position end))))))
504
+
505
+ ;; fence$B$NHO0O$r@_Dj$9$k(B
506
+ (when select-mode (insert "|"))
507
+ (setq sekka-fence-end (point-marker))
508
+
509
+ (sekka-debug-print (format "total-point:%d-%d\n"
510
+ (marker-position sekka-fence-start)
511
+ (marker-position sekka-fence-end)))
512
+ ;; UNDO$B:F3+(B
513
+ (sekka-enable-undo)))
514
+
515
+
516
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
517
+ ;; $BJQ498uJdA*Br%b!<%I(B
518
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
519
+ (let ((i 0))
520
+ (while (<= i ?\177)
521
+ (define-key sekka-select-mode-map (char-to-string i)
522
+ 'sekka-kakutei-and-self-insert)
523
+ (setq i (1+ i))))
524
+ (define-key sekka-select-mode-map "\C-m" 'sekka-select-kakutei)
525
+ (define-key sekka-select-mode-map "\C-g" 'sekka-select-cancel)
526
+ (define-key sekka-select-mode-map "q" 'sekka-select-cancel)
527
+ (define-key sekka-select-mode-map "\C-a" 'sekka-select-kanji)
528
+ (define-key sekka-select-mode-map "\C-p" 'sekka-select-prev)
529
+ (define-key sekka-select-mode-map "\C-n" 'sekka-select-next)
530
+ (define-key sekka-select-mode-map sekka-rK-trans-key 'sekka-select-next)
531
+ (define-key sekka-select-mode-map " " 'sekka-select-next)
532
+ (define-key sekka-select-mode-map "\C-u" 'sekka-select-hiragana)
533
+ (define-key sekka-select-mode-map "\C-i" 'sekka-select-katakana)
534
+ (define-key sekka-select-mode-map "\C-k" 'sekka-select-katakana)
535
+ (define-key sekka-select-mode-map "\C-l" 'sekka-select-hankaku)
536
+ (define-key sekka-select-mode-map "\C-e" 'sekka-select-zenkaku)
537
+
538
+
539
+
540
+ ;; $BJQ49$r3NDj$7F~NO$5$l$?%-!<$r:FF~NO$9$k4X?t(B
541
+ (defun sekka-kakutei-and-self-insert (arg)
542
+ "$B8uJdA*Br$r3NDj$7!"F~NO$5$l$?J8;z$rF~NO$9$k(B"
543
+ (interactive "P")
544
+ (sekka-select-kakutei)
545
+ (setq unread-command-events (list last-command-event)))
546
+
547
+ ;; $B8uJdA*Br>uBV$G$NI=<(99?7(B
548
+ (defun sekka-select-update-display ()
549
+ (sekka-display-function
550
+ (marker-position sekka-fence-start)
551
+ (marker-position sekka-fence-end)
552
+ sekka-select-mode))
553
+
554
+
555
+ ;; $B8uJdA*Br$r3NDj$9$k(B
556
+ (defun sekka-select-kakutei ()
557
+ "$B8uJdA*Br$r3NDj$9$k(B"
558
+ (interactive)
559
+ ;; $B8uJdHV9f%j%9%H$r%P%C%/%"%C%W$9$k!#(B
560
+ (setq sekka-cand-cur-backup sekka-cand-cur)
561
+ ;; $B%5!<%P!<$K3NDj$7$?C18l$rEA$($k(B($B<-=q3X=,(B)
562
+ (let* ((kouho (nth sekka-cand-cur sekka-henkan-kouho-list))
563
+ (_ (sekka-debug-print (format "2:sekka-cand-cur=%s\n" sekka-cand-cur)))
564
+ (_ (sekka-debug-print (format "2:kouho=%s\n" kouho)))
565
+ (tango (car kouho))
566
+ (key (caddr kouho))
567
+ (kind (nth sekka-kind-index kouho)))
568
+ (when (eq 'j kind)
569
+ (sekka-kakutei-request key tango)))
570
+ (setq sekka-select-mode nil)
571
+ (run-hooks 'sekka-select-mode-end-hook)
572
+ (sekka-select-update-display))
573
+
574
+
575
+ ;; $B8uJdA*Br$r%-%c%s%;%k$9$k(B
576
+ (defun sekka-select-cancel ()
577
+ "$B8uJdA*Br$r%-%c%s%;%k$9$k(B"
578
+ (interactive)
579
+ ;; $B%+%l%s%H8uJdHV9f$r%P%C%/%"%C%W$7$F$$$?8uJdHV9f$GI|85$9$k!#(B
580
+ (setq sekka-cand-cur sekka-cand-cur-backup)
581
+ (setq sekka-select-mode nil)
582
+ (run-hooks 'sekka-select-mode-end-hook)
583
+ (sekka-select-update-display))
584
+
585
+ ;; $BA0$N8uJd$K?J$a$k(B
586
+ (defun sekka-select-prev ()
587
+ "$BA0$N8uJd$K?J$a$k(B"
588
+ (interactive)
589
+ ;; $BA0$N8uJd$K@Z$j$+$($k(B
590
+ (decf sekka-cand-cur)
591
+ (when (> 0 sekka-cand-cur)
592
+ (setq sekka-cand-cur (- sekka-cand-len 1)))
593
+ (sekka-select-update-display))
594
+
595
+ ;; $B<!$N8uJd$K?J$a$k(B
596
+ (defun sekka-select-next ()
597
+ "$B<!$N8uJd$K?J$a$k(B"
598
+ (interactive)
599
+ ;; $B<!$N8uJd$K@Z$j$+$($k(B
600
+ (setq sekka-cand-cur
601
+ (if (< sekka-cand-cur (- sekka-cand-len 1))
602
+ (+ sekka-cand-cur 1)
603
+ 0))
604
+ (sekka-select-update-display))
605
+
606
+ ;; $B;XDj$5$l$?(B type $B$N8uJd$rH4$-=P$9(B
607
+ (defun sekka-select-by-type-filter ( _type )
608
+ (let ((lst '()))
609
+ (mapcar
610
+ (lambda (x)
611
+ (let ((sym (nth sekka-kind-index x)))
612
+ (when (eq sym _type)
613
+ (push x lst))))
614
+ sekka-henkan-kouho-list)
615
+ (sekka-debug-print (format "filterd-lst = %S" (reverse lst)))
616
+ (car (reverse lst))))
617
+
618
+ ;; $B;XDj$5$l$?(B type $B$N8uJd$K6/@)E*$K@Z$j$+$($k(B
619
+ (defun sekka-select-by-type ( _type )
620
+ (let ((kouho (sekka-select-by-type-filter _type)))
621
+ (if (null kouho)
622
+ (cond
623
+ ((eq _type 'j)
624
+ (message "Sekka: $B4A;z$N8uJd$O$"$j$^$;$s!#(B"))
625
+ ((eq _type 'h)
626
+ (message "Sekka: $B$R$i$,$J$N8uJd$O$"$j$^$;$s!#(B"))
627
+ ((eq _type 'k)
628
+ (message "Sekka: $B%+%?%+%J$N8uJd$O$"$j$^$;$s!#(B"))
629
+ ((eq _type 'l)
630
+ (message "Sekka: $BH>3Q$N8uJd$O$"$j$^$;$s!#(B"))
631
+ ((eq _type 'z)
632
+ (message "Sekka: $BA43Q$N8uJd$O$"$j$^$;$s!#(B")))
633
+ (let ((num (nth sekka-id-index kouho)))
634
+ (setq sekka-cand-cur num)
635
+ (sekka-select-update-display)))))
636
+
637
+ (defun sekka-select-kanji ()
638
+ "$B4A;z8uJd$K6/@)E*$K@Z$j$+$($k(B"
639
+ (interactive)
640
+ (sekka-select-by-type 'j))
641
+
642
+ (defun sekka-select-hiragana ()
643
+ "$B$R$i$,$J8uJd$K6/@)E*$K@Z$j$+$($k(B"
644
+ (interactive)
645
+ (sekka-select-by-type 'h))
646
+
647
+ (defun sekka-select-katakana ()
648
+ "$B%+%?%+%J8uJd$K6/@)E*$K@Z$j$+$($k(B"
649
+ (interactive)
650
+ (sekka-select-by-type 'k))
651
+
652
+ (defun sekka-select-hankaku ()
653
+ "$BH>3Q8uJd$K6/@)E*$K@Z$j$+$($k(B"
654
+ (interactive)
655
+ (sekka-select-by-type 'l))
656
+
657
+ (defun sekka-select-zenkaku ()
658
+ "$BH>3Q8uJd$K6/@)E*$K@Z$j$+$($k(B"
659
+ (interactive)
660
+ (sekka-select-by-type 'z))
661
+
662
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
663
+ ;; $B%m!<%^;z4A;zJQ494X?t(B
664
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
665
+ (defun sekka-rK-trans ()
666
+ "$B%m!<%^;z4A;zJQ49$r$9$k!#(B
667
+ $B!&%+!<%=%k$+$i9TF,J}8~$K%m!<%^;zNs$,B3$/HO0O$G%m!<%^;z4A;zJQ49$r9T$&!#(B"
668
+ (interactive)
669
+ ; (print last-command) ; DEBUG
670
+
671
+ (cond
672
+ ;; $B%?%$%^!<%$%Y%s%H$r@_Dj$7$J$$>r7o(B
673
+ ((or
674
+ sekka-timer
675
+ (> 1 sekka-realtime-guide-running-seconds)
676
+ ))
677
+ (t
678
+ ;; $B%?%$%^!<%$%Y%s%H4X?t$NEPO?(B
679
+ (progn
680
+ (let
681
+ ((ov-point
682
+ (save-excursion
683
+ (forward-line 1)
684
+ (point))))
685
+ (setq sekka-guide-overlay
686
+ (make-overlay ov-point ov-point (current-buffer))))
687
+ (setq sekka-timer
688
+ (run-at-time 0.1 sekka-realtime-guide-interval
689
+ 'sekka-realtime-guide)))))
690
+
691
+ ;; $B%,%$%II=<(7QB32s?t$N99?7(B
692
+ (when (< 0 sekka-realtime-guide-running-seconds)
693
+ (setq sekka-timer-rest
694
+ (/ sekka-realtime-guide-running-seconds
695
+ sekka-realtime-guide-interval)))
696
+
697
+ ;; $B:G8e$KJQ49$7$?9THV9f$N99?7(B
698
+ (setq sekka-last-lineno (line-number-at-pos (point)))
699
+
700
+ (cond
701
+ (sekka-select-mode
702
+ ;; $BJQ49Cf$K8F=P$5$l$?$i!"8uJdA*Br%b!<%I$K0\9T$9$k!#(B
703
+ (funcall (lookup-key sekka-select-mode-map sekka-rK-trans-key)))
704
+
705
+
706
+ (t
707
+ (cond
708
+
709
+ ((eq (sekka-char-charset (preceding-char)) 'ascii)
710
+ ;; $B%+!<%=%kD>A0$,(B alphabet $B$@$C$?$i(B
711
+ (let ((end (point))
712
+ (gap (sekka-skip-chars-backward)))
713
+ (when (/= gap 0)
714
+ ;; $B0UL#$N$"$kF~NO$,8+$D$+$C$?$N$GJQ49$9$k(B
715
+ (let (
716
+ (b (+ end gap))
717
+ (e end))
718
+ (when (sekka-henkan-region b e)
719
+ (if (eq (char-before b) ?/)
720
+ (setq b (- b 1)))
721
+ (delete-region b e)
722
+ (goto-char b)
723
+ (insert (sekka-get-display-string))
724
+ (setq e (point))
725
+ (sekka-display-function b e nil)
726
+ (sekka-select-kakutei)
727
+ )))))
728
+
729
+
730
+ ((sekka-kanji (preceding-char))
731
+
732
+ ;; $B%+!<%=%kD>A0$,(B $BA43Q$G4A;z0J30(B $B$@$C$?$i8uJdA*Br%b!<%I$K0\9T$9$k!#(B
733
+ ;; $B$^$?!":G8e$K3NDj$7$?J8;zNs$HF1$8$+$I$&$+$b3NG'$9$k!#(B
734
+ (when (and
735
+ (<= (marker-position sekka-fence-start) (point))
736
+ (<= (point) (marker-position sekka-fence-end))
737
+ (string-equal sekka-last-fix (buffer-substring
738
+ (marker-position sekka-fence-start)
739
+ (marker-position sekka-fence-end))))
740
+ ;; $BD>A0$KJQ49$7$?(Bfence$B$NHO0O$KF~$C$F$$$?$i!"JQ49%b!<%I$K0\9T$9$k!#(B
741
+ (setq sekka-select-mode t)
742
+ (sekka-debug-print "henkan mode ON\n")
743
+
744
+ ;; $BI=<(>uBV$r8uJdA*Br%b!<%I$K@ZBX$($k!#(B
745
+ (sekka-display-function
746
+ (marker-position sekka-fence-start)
747
+ (marker-position sekka-fence-end)
748
+ t))))
749
+ )))
750
+
751
+
752
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
753
+ ;; $B%-%c%T%?%i%$%:(B/$B%"%s%-%c%T%?%i%$%:JQ49(B
754
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
755
+ (defun sekka-capitalize-trans ()
756
+ "$B%-%c%T%?%i%$%:JQ49$r9T$&(B
757
+ $B!&%+!<%=%k$+$i9TF,J}8~$K%m!<%^;zNs$r8+$D$1!"@hF,J8;z$NBgJ8;z>.J8;z$rH?E>$9$k(B"
758
+ (interactive)
759
+
760
+ (cond
761
+ (sekka-select-mode
762
+ ;; $B8uJdA*Br%b!<%I$G$OH?1~$7$J$$!#(B
763
+ ;; do nothing
764
+ )
765
+ ((eq (sekka-char-charset (preceding-char)) 'ascii)
766
+ ;; $B%+!<%=%kD>A0$,(B alphabet $B$@$C$?$i(B
767
+ (sekka-debug-print "capitalize(2)!\n")
768
+
769
+ (let ((end (point))
770
+ (gap (sekka-skip-chars-backward)))
771
+ (when (/= gap 0)
772
+ ;; $B0UL#$N$"$kF~NO$,8+$D$+$C$?$N$GJQ49$9$k(B
773
+ (let* (
774
+ (b (+ end gap))
775
+ (e end)
776
+ (roman-str (buffer-substring-no-properties b e)))
777
+ (sekka-debug-print (format "capitalize %d %d [%s]" b e roman-str))
778
+ (setq case-fold-search nil)
779
+ (cond
780
+ ((string-match-p "^[A-Z]" roman-str)
781
+ (downcase-region b (+ b 1)))
782
+ ((string-match-p "^[a-z]" roman-str)
783
+ (upcase-region b (+ b 1))))))))
784
+ ))
785
+
786
+
787
+ ;; $BA43Q$G4A;z0J30$NH=Dj4X?t(B
788
+ (defun sekka-nkanji (ch)
789
+ (and (eq (sekka-char-charset ch) 'japanese-jisx0208)
790
+ (not (string-match "[$B0!(B-$Bt$(B]" (char-to-string ch)))))
791
+
792
+ (defun sekka-kanji (ch)
793
+ (eq (sekka-char-charset ch) 'japanese-jisx0208))
794
+
795
+
796
+ ;; $B%m!<%^;z4A;zJQ49;~!"JQ49BP>]$H$9$k%m!<%^;z$rFI$_Ht$P$94X?t(B
797
+ (defun sekka-skip-chars-backward ()
798
+ (let* (
799
+ (skip-chars
800
+ (if auto-fill-function
801
+ ;; auto-fill-mode $B$,M-8z$K$J$C$F$$$k>l9g2~9T$,$"$C$F$b(Bskip$B$rB3$1$k(B
802
+ (concat sekka-skip-chars "\n")
803
+ ;; auto-fill-mode$B$,L58z$N>l9g$O$=$N$^$^(B
804
+ sekka-skip-chars))
805
+
806
+ ;; $B%^!<%/$5$l$F$$$k0LCV$r5a$a$k!#(B
807
+ (pos (or (and (markerp (mark-marker)) (marker-position (mark-marker)))
808
+ 1))
809
+
810
+ ;; $B>r7o$K%^%C%A$9$k4V!"A0J}J}8~$K%9%-%C%W$9$k!#(B
811
+ (result (save-excursion
812
+ (skip-chars-backward skip-chars (and (< pos (point)) pos))))
813
+ (limit-point 0))
814
+
815
+ (if auto-fill-function
816
+ ;; auto-fill-mode$B$,M-8z$N;~(B
817
+ (progn
818
+ (save-excursion
819
+ (backward-paragraph)
820
+ (when (< 1 (point))
821
+ (forward-line 1))
822
+ (goto-char (point-at-bol))
823
+ (let (
824
+ (start-point (point)))
825
+ (setq limit-point
826
+ (+
827
+ start-point
828
+ (skip-chars-forward (concat "\t " sekka-stop-chars) (point-at-eol))))))
829
+
830
+ ;; (sekka-debug-print (format "(point) = %d result = %d limit-point = %d\n" (point) result limit-point))
831
+ ;; (sekka-debug-print (format "a = %d b = %d \n" (+ (point) result) limit-point))
832
+
833
+ ;; $B%Q%i%0%i%U0LCV$G%9%H%C%W$9$k(B
834
+ (if (< (+ (point) result) limit-point)
835
+ (-
836
+ limit-point
837
+ (point))
838
+ result))
839
+
840
+ ;; auto-fill-mode$B$,L58z$N;~(B
841
+ (progn
842
+ (save-excursion
843
+ (goto-char (point-at-bol))
844
+ (let (
845
+ (start-point (point)))
846
+ (setq limit-point
847
+ (+
848
+ start-point
849
+ (skip-chars-forward (concat "\t " sekka-stop-chars) (point-at-eol))))))
850
+
851
+ ;; (sekka-debug-print (format "(point) = %d result = %d limit-point = %d\n" (point) result limit-point))
852
+ ;; (sekka-debug-print (format "a = %d b = %d \n" (+ (point) result) limit-point))
853
+
854
+ (if (< (+ (point) result) limit-point)
855
+ ;; $B%$%s%G%s%H0LCV$G%9%H%C%W$9$k!#(B
856
+ (-
857
+ limit-point
858
+ (point))
859
+ result)))))
860
+
861
+
862
+ ;;;
863
+ ;;; with viper
864
+ ;;;
865
+ ;; code from skk-viper.el
866
+ (defun sekka-viper-normalize-map ()
867
+ (let ((other-buffer
868
+ (if (featurep 'xemacs)
869
+ (local-variable-p 'minor-mode-map-alist nil t)
870
+ (local-variable-if-set-p 'minor-mode-map-alist))))
871
+ ;; for current buffer and buffers to be created in the future.
872
+ ;; substantially the same job as viper-harness-minor-mode does.
873
+ (viper-normalize-minor-mode-map-alist)
874
+ (setq-default minor-mode-map-alist minor-mode-map-alist)
875
+ (when other-buffer
876
+ ;; for buffers which are already created and have
877
+ ;; the minor-mode-map-alist localized by Viper.
878
+ (dolist (buf (buffer-list))
879
+ (with-current-buffer buf
880
+ (unless (assq 'sekka-mode minor-mode-map-alist)
881
+ (setq minor-mode-map-alist
882
+ (append (list (cons 'sekka-mode sekka-mode-map)
883
+ (cons 'sekka-select-mode
884
+ sekka-select-mode-map))
885
+ minor-mode-map-alist)))
886
+ (viper-normalize-minor-mode-map-alist))))))
887
+
888
+ (defun sekka-viper-init-function ()
889
+ (sekka-viper-normalize-map)
890
+ (remove-hook 'sekka-mode-hook 'sekka-viper-init-function))
891
+
892
+ (defun sekka-sticky-shift-init-function ()
893
+ ;; sticky-shift
894
+ (define-key global-map sticky-key sticky-map)
895
+ (mapcar (lambda (pair)
896
+ (define-key sticky-map (car pair)
897
+ `(lambda()(interactive)
898
+ (if ,(< 0 (length (cdr pair)))
899
+ (setq unread-command-events
900
+ (cons ,(string-to-char (cdr pair)) unread-command-events))
901
+ nil))))
902
+ sticky-list)
903
+ (define-key sticky-map sticky-key '(lambda ()(interactive)(insert sticky-key))))
904
+
905
+ (defun sekka-realtime-guide ()
906
+ "$B%j%"%k%?%$%`$GJQ49Cf$N%,%$%I$r=P$9(B
907
+ sekka-mode$B$,(BON$B$N4VCf8F$S=P$5$l$k2DG=@-$,$"$k!#(B"
908
+ (cond
909
+ ((or (null sekka-mode)
910
+ (> 1 sekka-timer-rest))
911
+ (cancel-timer sekka-timer)
912
+ (setq sekka-timer nil)
913
+ (delete-overlay sekka-guide-overlay))
914
+ (sekka-guide-overlay
915
+ ;; $B;D$j2s?t$N%G%/%j%a%s%H(B
916
+ (setq sekka-timer-rest (- sekka-timer-rest 1))
917
+
918
+ ;; $B%+!<%=%k$,(Bsekka-realtime-guide-limit-lines $B$r$O$_=P$7$F$$$J$$$+%A%'%C%/(B
919
+ (sekka-debug-print (format "sekka-last-lineno [%d] : current-line" sekka-last-lineno (line-number-at-pos (point))))
920
+ (when (< 0 sekka-realtime-guide-limit-lines)
921
+ (let ((diff-lines (abs (- (line-number-at-pos (point)) sekka-last-lineno))))
922
+ (when (<= sekka-realtime-guide-limit-lines diff-lines)
923
+ (setq sekka-timer-rest 0))))
924
+
925
+ (let* (
926
+ (end (point))
927
+ (gap (sekka-skip-chars-backward)))
928
+ (if
929
+ (or
930
+ (when (fboundp 'minibufferp)
931
+ (minibufferp))
932
+ (= gap 0))
933
+ ;; $B>e2<%9%Z!<%9$,L5$$(B $B$^$?$O(B $BJQ49BP>]$,L5$7$J$i%,%$%I$OI=<($7$J$$!#(B
934
+ (overlay-put sekka-guide-overlay 'before-string "")
935
+ ;; $B0UL#$N$"$kF~NO$,8+$D$+$C$?$N$G%,%$%I$rI=<($9$k!#(B
936
+ (let* (
937
+ (b (+ end gap))
938
+ (e end)
939
+ (str (buffer-substring-no-properties b e))
940
+ (lst (if (string-match "^[\s\t]+$" str)
941
+ '()
942
+ (if (string= str sekka-guide-lastquery)
943
+ sekka-guide-lastresult
944
+ (progn
945
+ (setq sekka-guide-lastquery str)
946
+ (setq sekka-guide-lastresult (sekka-henkan-request str 1))
947
+ sekka-guide-lastresult))))
948
+ (mess
949
+ (if (< 0 (length lst))
950
+ (concat "[" (caar lst) "]")
951
+ "")))
952
+ (sekka-debug-print (format "realtime guide [%s]" str))
953
+ (move-overlay sekka-guide-overlay
954
+ ;; disp-point (min (point-max) (+ disp-point 1))
955
+ b e
956
+ (current-buffer))
957
+ (overlay-put sekka-guide-overlay 'before-string mess))))
958
+ (overlay-put sekka-guide-overlay 'face 'sekka-guide-face))))
959
+
960
+
961
+ ;;;
962
+ ;;; human interface
963
+ ;;;
964
+ (define-key sekka-mode-map sekka-rK-trans-key 'sekka-rK-trans)
965
+ (define-key sekka-mode-map "\M-j" 'sekka-capitalize-trans)
966
+ (or (assq 'sekka-mode minor-mode-map-alist)
967
+ (setq minor-mode-map-alist
968
+ (append (list
969
+ (cons 'sekka-mode sekka-mode-map))
970
+ minor-mode-map-alist)))
971
+
972
+
973
+
974
+ ;; sekka-mode $B$N>uBVJQ994X?t(B
975
+ ;; $B@5$N0z?t$N>l9g!">o$K(B sekka-mode $B$r3+;O$9$k(B
976
+ ;; {$BIi(B,0}$B$N0z?t$N>l9g!">o$K(B sekka-mode $B$r=*N;$9$k(B
977
+ ;; $B0z?tL5$7$N>l9g!"(Bsekka-mode $B$r%H%0%k$9$k(B
978
+
979
+ ;; buffer $BKh$K(B sekka-mode $B$rJQ99$9$k(B
980
+ (defun sekka-mode (&optional arg)
981
+ "Sekka mode $B$O(B $B%m!<%^;z$+$iD>@\4A;zJQ49$9$k$?$a$N(B minor mode $B$G$9!#(B
982
+ $B0z?t$K@5?t$r;XDj$7$?>l9g$O!"(BSekka mode $B$rM-8z$K$7$^$9!#(B
983
+
984
+ Sekka $B%b!<%I$,M-8z$K$J$C$F$$$k>l9g(B \\<sekka-mode-map>\\[sekka-rK-trans] $B$G(B
985
+ point $B$+$i9TF,J}8~$KF1<o$NJ8;zNs$,B3$/4V$r4A;zJQ49$7$^$9!#(B
986
+
987
+ $BF1<o$NJ8;zNs$H$O0J2<$N$b$N$r;X$7$^$9!#(B
988
+ $B!&H>3Q%+%?%+%J$H(Bsekka-stop-chars $B$K;XDj$7$?J8;z$r=|$/H>3QJ8;z(B
989
+ $B!&4A;z$r=|$/A43QJ8;z(B"
990
+ (interactive "P")
991
+ (sekka-mode-internal arg nil))
992
+
993
+ ;; $BA4%P%C%U%!$G(B sekka-mode $B$rJQ99$9$k(B
994
+ (defun global-sekka-mode (&optional arg)
995
+ "Sekka mode $B$O(B $B%m!<%^;z$+$iD>@\4A;zJQ49$9$k$?$a$N(B minor mode $B$G$9!#(B
996
+ $B0z?t$K@5?t$r;XDj$7$?>l9g$O!"(BSekka mode $B$rM-8z$K$7$^$9!#(B
997
+
998
+ Sekka $B%b!<%I$,M-8z$K$J$C$F$$$k>l9g(B \\<sekka-mode-map>\\[sekka-rK-trans] $B$G(B
999
+ point $B$+$i9TF,J}8~$KF1<o$NJ8;zNs$,B3$/4V$r4A;zJQ49$7$^$9!#(B
1000
+
1001
+ $BF1<o$NJ8;zNs$H$O0J2<$N$b$N$r;X$7$^$9!#(B
1002
+ $B!&H>3Q%+%?%+%J$H(Bsekka-stop-chars $B$K;XDj$7$?J8;z$r=|$/H>3QJ8;z(B
1003
+ $B!&4A;z$r=|$/A43QJ8;z(B"
1004
+ (interactive "P")
1005
+ (sekka-mode-internal arg t))
1006
+
1007
+
1008
+ ;; sekka-mode $B$rJQ99$9$k6&DL4X?t(B
1009
+ (defun sekka-mode-internal (arg global)
1010
+ (or (local-variable-p 'sekka-mode (current-buffer))
1011
+ (make-local-variable 'sekka-mode))
1012
+ (if global
1013
+ (progn
1014
+ (setq-default sekka-mode (if (null arg) (not sekka-mode)
1015
+ (> (prefix-numeric-value arg) 0)))
1016
+ (sekka-kill-sekka-mode))
1017
+ (setq sekka-mode (if (null arg) (not sekka-mode)
1018
+ (> (prefix-numeric-value arg) 0))))
1019
+ (when sekka-use-viper
1020
+ (add-hook 'sekka-mode-hook 'sekka-viper-init-function))
1021
+ (when sekka-sticky-shift
1022
+ (add-hook 'sekka-mode-hook 'sekka-sticky-shift-init-function))
1023
+ (when sekka-mode (run-hooks 'sekka-mode-hook)))
1024
+
1025
+
1026
+ ;; buffer local $B$J(B sekka-mode $B$r:o=|$9$k4X?t(B
1027
+ (defun sekka-kill-sekka-mode ()
1028
+ (let ((buf (buffer-list)))
1029
+ (while buf
1030
+ (set-buffer (car buf))
1031
+ (kill-local-variable 'sekka-mode)
1032
+ (setq buf (cdr buf)))))
1033
+
1034
+
1035
+ ;; $BA4%P%C%U%!$G(B sekka-input-mode $B$rJQ99$9$k(B
1036
+ (defun sekka-input-mode (&optional arg)
1037
+ "$BF~NO%b!<%IJQ99(B"
1038
+ (interactive "P")
1039
+ (if (< 0 arg)
1040
+ (progn
1041
+ (setq inactivate-current-input-method-function 'sekka-inactivate)
1042
+ (setq sekka-mode t))
1043
+ (setq inactivate-current-input-method-function nil)
1044
+ (setq sekka-mode nil)))
1045
+
1046
+
1047
+ ;; input method $BBP1~(B
1048
+ (defun sekka-activate (&rest arg)
1049
+ (sekka-input-mode 1))
1050
+ (defun sekka-inactivate (&rest arg)
1051
+ (sekka-input-mode -1))
1052
+ (register-input-method
1053
+ "japanese-sekka" "Japanese" 'sekka-activate
1054
+ "" "Roman -> Kanji&Kana"
1055
+ nil)
1056
+
1057
+ ;; input-method $B$H$7$FEPO?$9$k!#(B
1058
+ (set-language-info "Japanese" 'input-method "japanese-sekka")
1059
+ (setq default-input-method "japanese-sekka")
1060
+
1061
+ (defconst sekka-version
1062
+ " 0.8.0 " ;;VERSION;;
1063
+ )
1064
+ (defun sekka-version (&optional arg)
1065
+ "$BF~NO%b!<%IJQ99(B"
1066
+ (interactive "P")
1067
+ (message sekka-version))
1068
+
1069
+ (provide 'sekka)