Author: sasugaanija
Date: Mon Aug 27 07:56:31 2007
New Revision: 4900
Modified:
trunk/emacs/uim-key.el
trunk/emacs/uim-util.el
trunk/emacs/uim-var.el
trunk/emacs/uim.el
Log:
* emacs/uim-key.el
- (uim-this-command-keys): Rename to uim-translate-key.
- (uim-translate-key)
- Renamed from uim-this-command-keys and simplified.
- Move call of this-command-keys(-vector) to uim-process-input.
- Remove with-arg argument.
- Remove vector separation function.
- Remove complicated vector processing routine.
- Display a prompt when the function-key-map returnes a
translation function (ex. C-x @ c)
- Remove [escape escape] translation.
- (uim-separate-prefix-vector)
- New function extracted from uim-translate-key.
- Separate prefix vector and other from input vector.
- (uim-translate-escape-meta)
- New function extracted from uim-translate-key.
- Replace [escape escape] to [M-escape] for XEmacs
- (uim-process-keyvec)
- Return continue flag to wait latter inputs if the vector is
bound to a key map.
* emacs/uim.el
- (uim-process-input)
- Replace uim-this-command-keys to uim-translate-key
- Call uim-this-commnad-keys-vector to get key vector.
- Separate prefix vector from input vector.
- Change uim-el-agent bypass rule.
- Special prefix keys (such as Escape and C-x) are
passed to uim-el-agent anyway.
- (uim-process-agent-output)
- Set uim-wait-next-key when uim-process-keyvec returned
continue flag.
* emacs/uim-var.el
- (uim-stacked-key-vector): Remove
- (uim-translated-key-vector)
- New variable to manage key vector which has already been translated
through function-key-map.
- (uim-untranslated-key-vector)
- New variable to manage key vector which is not translated yet.
- (uim-wait-next-key)
- New variable
- (uim-prefix-ignore-next)
- Remove
- (uim-show-keystrokes)
- Renamed to uim-keystroke-displaying
- (uim-keystroke-displaying)
- Renamed from uim-show-keystrokes
* emacs/uim-util.el
- (uim-get-vector-from-head): New function to manage vector easily.
- (uim-get-vector-from-tail): Ditto
- (uim-cut-vector-from-head): Ditto
- (uim-vector-cdr): Ditto
- (uim-vector-car): Ditto
Modified: trunk/emacs/uim-key.el
==============================================================================
--- trunk/emacs/uim-key.el (original)
+++ trunk/emacs/uim-key.el Mon Aug 27 07:56:31 2007
@@ -195,7 +195,9 @@
;;
(defun uim-process-keyvec (uim-key-vector &optional count)
(let ((bind (uim-key-binding uim-key-vector t))
- keyvectmp)
+ keyvectmp
+ continue
+ )
(uim-debug (format "uim-process-keyvec"))
(if uim-emacs
@@ -203,7 +205,12 @@
(setq deactivate-mark nil))
(unwind-protect
- (cond (count
+ (cond ((keymapp bind)
+ (uim-debug "bind is keymap")
+ (setq continue t)
+ )
+
+ (count
(setq prefix-arg count)
(uim-command-execute
(uim-key-binding uim-key-vector t))
@@ -269,6 +276,7 @@
(if uim-emacs
(setq uim-deactivate-mark deactivate-mark))
)
+ continue
)
)
@@ -511,205 +519,172 @@
)
+(defun uim-separate-prefix-vector (key-vector)
+ (let (key-vector-prefix key-vector-main)
+ (setq key-vector-main (uim-last-onestroke-key key-vector))
+ (setq key-vector-prefix
+ (uim-get-vector-from-head key-vector
+ (- (length key-vector)
+ (length key-vector-main))))
+ ;;(setq key-vector key-vector-main)
+ ;;(setq uim-prefix-arg-vector key-vector-prefix)
+ (list key-vector-main key-vector-prefix))
+ )
+
+
;;
;; get this-command-keys with symbol lists vector
;;
-(defun uim-this-command-keys (with-arg)
- (let (keyvec replace-continue fmap-continue bind)
-
- (if uim-xemacs
- (setq keyvec (this-command-keys)))
-
- (if uim-emacs
- (setq keyvec (this-command-keys-vector)))
-
- (if uim-prefix-ignore-next
- ;; avoid mysterious key event on Emacs-21 on terminal
- ;; ex. C-u 1 0 escape f
- (progn
- (uim-debug "ignore this key vector")
- (setq keyvec nil)
- (setq uim-prefix-ignore-next nil)
- )
- (if with-arg
- ;; key with prefix arg
- (let* ((rkeylist (reverse (append keyvec nil))))
- (setq keyvec (uim-last-onestroke-key keyvec))
- (if (= (length keyvec) 2)
- ;; Only Emacs-21 returns two stroke keys at 1st time
- (setq uim-prefix-arg-vector
- (vconcat (reverse (cdr (cdr rkeylist)))))
- (setq uim-prefix-arg-vector
- (vconcat (reverse (cdr rkeylist)))))
- ;; work around
- (if (= (length keyvec) 2)
- (setq uim-prefix-ignore-next t))
- )))
-
- (uim-debug (format "keyvec %s" keyvec))
-
- ;; translate key vector with function-key-map
-
- (let (fmap key replaced)
- (let* ((merged-vector (vconcat uim-stacked-key-vector keyvec))
- (merged-list (append merged-vector nil))
- (stacked-list nil)
- merged-list-backup
- done)
- (uim-debug (format "merged-list: %s" merged-list))
+(defun uim-translate-key (input-vector)
+ (let (translated-vector map (non-error t)
+ (input-vector-main input-vector)
+ (input-vector-prefix nil)
+ input-vector-main-backup
+ translated bind)
- (catch 'fmap-loop
- (while merged-list
+ (uim-debug (format "input-vector: %s" input-vector))
- (setq merged-list-backup merged-list)
+ (catch 'fmap-loop
+ (while input-vector-main
+ (setq input-vector-main-backup input-vector-main)
- (setq bind (uim-key-binding (vconcat merged-list)))
+ (setq bind (uim-key-binding input-vector-main))
- (if (and bind
- (not (integerp bind)))
- (progn
- (uim-debug "skip function-key-map lookup")
- (setq uim-stacked-key-vector
- (vconcat stacked-list merged-list))
- (throw 'fmap-loop t))
-
- (setq fmap (lookup-key function-key-map (vconcat merged-list)))
+ (if (and bind
+ (not (integerp bind)))
+ (progn
+ (uim-debug "skip function-key-map lookup")
+ ;;(setq translated-vector input-vector)
+ (setq translated-vector nil)
+ (throw 'fmap-loop t))
+
+ (setq translated (lookup-key function-key-map input-vector-main))
- (if (and (or (not fmap)
- (integerp fmap))
- (boundp 'local-function-key-map))
- (setq fmap (lookup-key local-function-key-map
- (vconcat merged-list))))
-
-
- (if (or (not fmap)
- (integerp fmap))
- (progn
- (setq merged-list
- (append (uim-remove-shift (vconcat merged-list)) nil))
-
- (setq bind (uim-key-binding (vconcat merged-list)))
-
- (if (and bind
- (not (integerp bind)))
-
- (progn
- (uim-debug "skip function-key-map lookup (remove
shift)")
- (setq uim-stacked-key-vector
- (vconcat stacked-list merged-list))
- (throw 'fmap-loop t))
-
- ;; ä function-key-map
- (setq fmap (lookup-key function-key-map
- (vconcat merged-list)))
-
- (if (and (or (not fmap)
- (integerp fmap))
- (boundp 'local-function-key-map))
- (setq fmap (lookup-key local-function-key-map
- (vconcat merged-list))))
+ (if (and (or (not translated)
+ (integerp translated))
+ (boundp 'local-function-key-map))
+ (setq translated (lookup-key local-function-key-map
+ input-vector-main)))
+
+ (if (or (not translated)
+ (integerp translated))
+ (progn
+ (setq input-vector-main (uim-remove-shift input-vector-main))
+
+ (setq bind (uim-key-binding input-vector-main))
+
+ (if (and bind
+ (not (integerp bind)))
+
+ (progn
+ (uim-debug "skip function-key-map lookup (remove shift)")
+ ;;(setq translated-vector input-vector)
+ (setq translated-vector
+ (vconcat input-vector-prefix input-vector-main))
+ (throw 'fmap-loop t))
+
+ ;; ä function-key-map
+ (setq translated (lookup-key function-key-map
+ input-vector-main))
+
+ (if (and (or (not translated)
+ (integerp translated))
+ (boundp 'local-function-key-map))
+ (setq translated (lookup-key local-function-key-map
+ input-vector-main)))
+ (uim-debug "*** cannot remove shift")
- (if (not fmap)
- (setq merged-list merged-list-backup)))))
+ (if (not translated)
+ (setq input-vector-main input-vector-main-backup)))))
-
- (cond ((vectorp fmap)
- ;; vector: replace
- (uim-debug (format "vector: %s" (vconcat merged-list)))
- (setq uim-stacked-key-vector
- (vconcat stacked-list fmap))
- (throw 'fmap-loop t)
- )
- ((keymapp fmap)
- ;; keymap: wait next
- (uim-debug (format "keymap: %s" (vconcat merged-list)))
- (setq fmap-continue t)
- (setq uim-stacked-key-vector merged-vector)
- (throw 'fmap-loop t)
- )
- ((functionp fmap)
- (uim-debug (format "function: %s" (vconcat merged-list)))
- (setq fmap (funcall fmap nil))
- (if (vectorp fmap)
- (setq uim-stacked-key-vector (vconcat stacked-list
fmap))
- )
- (throw 'fmap-loop t)
- )
- ))
-
- (setq merged-list merged-list-backup)
-
- (setq stacked-list (append stacked-list (list (car merged-list))))
- (setq merged-list (cdr merged-list))
- )
+ (cond ((not translated)
+ )
- (setq uim-stacked-key-vector merged-vector))))
-
- ;; Replate [escape escape] with [M-escape] on XEmacs
- ;; Some special keys cannot be used with escape key on terminal
- (when (and uim-xemacs
- (>= (length uim-stacked-key-vector) 2)
- (equal (aref uim-stacked-key-vector 0)
- (uim-xemacs-make-event [(escape)])))
- ;; append meta
- (setq uim-stacked-key-vector
- (vector
- (uim-xemacs-make-event
- (vector
- (cons 'meta
- (aref (uim-convert-char-to-symbolvector
- (key-description (vconcat
- (cdr (append
- uim-stacked-key-vector
- nil)))))
- 0)))))))
+ ((vectorp translated)
+ ;; vector ... replace immediately
+ (uim-debug (format "translated is vector: %s" translated))
+ (setq translated-vector
+ (vconcat input-vector-prefix translated))
+ (throw 'fmap-loop t))
+
+ ((keymapp translated)
+ ;; keymap ... wait next input
+ (uim-debug (format "translated is keymap: %s" translated))
+ (setq map translated)
+ (throw 'fmap-loop t))
+
+
+ ((functionp translated)
+ ;; function ... call immediately and use returned value
+ (uim-debug (format "translated is function: %s" translated))
+ ;;(setq func translated)
+
+
+ (if (not uim-keystroke-displaying)
+ (setq uim-keystroke-displaying (sit-for echo-keystrokes)))
+
+ (if uim-keystroke-displaying
+ (let (message-log-max)
+ (message (concat (key-description
+ (vconcat uim-prefix-arg-vector
+ input-vector))
+ "-")))
+ )
+ (unwind-protect
+ (setq translated-vector
+ (vconcat input-vector-prefix (funcall translated
nil)))
+ (when (not translated-vector)
+ (setq non-error nil)
+ (throw 'fmap-loop nil)))
+
+ (throw 'fmap-loop t))
+
+ ((stringp translated)
+ ;; string ... replace
+ (uim-debug (format "translated is string:%s"
+ translated))
+ (setq translated-vector
+ (char-to-string (aref translated
+ (- (length translated) 1))))
+ (throw 'fmap-loop t))
+ ))
+ (setq input-vector-main input-vector-main-backup)
- (uim-debug (format "stacked-key-vector: %s" uim-stacked-key-vector))
-
- (cond ((and uim-preedit-keymap-enabled
- (uim-is-escape uim-stacked-key-vector))
- (uim-debug "stacked-key is Escape")
- ;; Return escape key
- (if uim-emacs
- (setq keyvec [27]))
- (if uim-xemacs
- (setq keyvec (vector (uim-xemacs-make-event [escape]))))
- (setq uim-stacked-key-vector nil)
- )
- ((or (and uim-preedit-keymap-enabled
- (or
- (and (or (eq (car-safe (aref uim-stacked-key-vector 0))
- 'menu-bar)
- (eq (car-safe (aref uim-stacked-key-vector 0))
- 'tool-bar))
- (keymapp (uim-key-binding uim-stacked-key-vector)))
-
- (and fmap-continue ;; wait ESC- key vector
- (uim-is-start-with-escape uim-stacked-key-vector))
- ))
-
- (and (not uim-preedit-keymap-enabled)
- (or (and fmap-continue
- (not (commandp (uim-key-binding
uim-stacked-key-vector t))))
- (keymapp (uim-key-binding uim-stacked-key-vector t))))
- uim-prefix-ignore-next ;; work around for Emacs-21 prefix arg
- )
- (uim-debug "wait next")
- (setq keyvec nil))
- (t
- ;; No need to wait any more. Return current keys.
- (setq keyvec uim-stacked-key-vector)
- (setq uim-stacked-key-vector nil))
- )
+ (setq input-vector-prefix
+ (vconcat input-vector-prefix (uim-vector-car input-vector-main)))
- keyvec
- )
+ (setq input-vector-main
+ (uim-vector-cdr input-vector-main))) ;; end of while
+
+ (setq translated-vector nil)) ;; end of catch
+
+ (uim-debug (format "output vector: %s" translated-vector))
+ (list translated-vector map non-error))
)
+
+
+;; Replate [escape escape] with [M-escape] on XEmacs
+;; Some special keys cannot be used with escape key on terminal
+(defun uim-translate-escape-meta (input-vector)
+ (if (and uim-xemacs
+ (>= (length input-vector) 2)
+ (equal (aref input-vector 0)
+ (uim-xemacs-make-event [(escape)])))
+ ;; append meta
+ (vconcat
+ (vector
+ (uim-xemacs-make-event
+ (vector (cons 'meta (aref (uim-convert-char-to-symbolvector
+ (key-description (uim-vector-cdr
+ input-vector))) 0)
+ ))))
+ (uim-cut-vector-from-head input-vector 2))
+ input-vector))
(provide 'uim-key)
Modified: trunk/emacs/uim-util.el
==============================================================================
--- trunk/emacs/uim-util.el (original)
+++ trunk/emacs/uim-util.el Mon Aug 27 07:56:31 2007
@@ -305,6 +305,34 @@
(defun uim-point ()
(window-point (get-buffer-window (current-buffer))))
+(defun uim-get-vector-from-head (vec n)
+ (if (and (<= n (length vec))
+ (> n 0))
+ (let ((vlist (append vec nil))
+ (ret '()))
+ (while (> n 0)
+ (setq ret (append ret (list (car vlist))))
+ (setq vlist (cdr vlist))
+ (setq n (- n 1)))
+ (vconcat ret))))
+
+(defun uim-get-vector-from-tail (vec n)
+ (if (and (<= n (length vec))
+ (> n 0))
+ (vconcat (nthcdr (- (length vec) n) (append vec nil)))))
+
+(defun uim-cut-vector-from-head (vec n)
+ (if (<= n (length vec))
+ (uim-get-vector-from-tail vec (- (length vec) n))))
+
+
+(defun uim-vector-cdr (vec)
+ (if (> (length vec) 1)
+ (uim-get-vector-from-tail vec (- (length vec) 1))))
+
+(defun uim-vector-car (vec)
+ (uim-get-vector-from-head vec 1))
+
(defun uim-delete-atom (list)
(if (and list
(not (atom list)))
Modified: trunk/emacs/uim-var.el
==============================================================================
--- trunk/emacs/uim-var.el (original)
+++ trunk/emacs/uim-var.el Mon Aug 27 07:56:31 2007
@@ -257,15 +257,16 @@
(defvar uim-prefix-arg nil
"Recent current-prefix-arg value.")
-;;(defvar uim-prefix-arg-vector-length 0)
-
;; unprocessed keys
-(defvar uim-stacked-key-vector nil)
+(defvar uim-wait-next-key nil)
+
+(defvar uim-translated-key-vector nil)
+(defvar uim-untranslated-key-vector nil)
+
(defvar uim-prefix-arg-vector nil)
-(defvar uim-prefix-ignore-next nil)
;; if non-nil, pressed keys are displayed at echo region
-(defvar uim-show-keystrokes nil)
+(defvar uim-keystroke-displaying nil)
;; keep original last-input-event to process the event correctly after
Modified: trunk/emacs/uim.el
==============================================================================
--- trunk/emacs/uim.el (original)
+++ trunk/emacs/uim.el Mon Aug 27 07:56:31 2007
@@ -876,162 +876,308 @@
(if uim-emacs
(setq uim-deactivate-mark t))
- (if (not uim-stacked-key-vector)
- (setq uim-show-keystrokes nil))
+ (if (not (or uim-translated-key-vector uim-untranslated-key-vector))
+ (setq uim-keystroke-displaying nil))
- ;; send an input key code to uim-el-agent
+ (let (new-key-vector
+ send-vector
+ send-vector-raw
+ issue-vector
+ send
+ issue
+ sendkey newvec count mouse wait discard)
+ (setq new-key-vector (uim-this-command-keys-vector))
+
+ (if current-prefix-arg
+ (let (vector-list)
+ (setq uim-prefix-arg current-prefix-arg)
+ (setq vector-list (uim-separate-prefix-vector new-key-vector))
+ (setq new-key-vector (car vector-list))
+ (setq uim-prefix-arg-vector (nth 1 vector-list))
+ (uim-debug (format "uim-prefix-arg-vector %s" uim-prefix-arg-vector))
+ (uim-debug (format "set uim-prefix-arg: %s" current-prefix-arg))))
+
+ (if uim-xemacs
+ (setq uim-original-input-event (copy-event last-input-event)))
+
+ (setq uim-untranslated-key-vector
+ (vconcat uim-untranslated-key-vector new-key-vector))
+
+ (let* ((translated-list (uim-translate-key uim-untranslated-key-vector))
+ (translated (nth 0 translated-list))
+ (map (nth 1 translated-list))
+ (non-error (nth 2 translated-list)))
+
+ (unwind-protect
+ (progn
+ (uim-debug (format "translated: %s" translated))
+ (uim-debug (if map "map: YES" "map: NO"))
+ (uim-debug (if non-error "non-error: YES" "func: NO"))
+
+ (cond ((stringp translated)
+ (setq uim-translated-key-vector translated)
+ (setq uim-untranslated-key-vector nil))
+
+ ((vectorp translated)
+ (setq send t) ;; t
+ (setq uim-translated-key-vector
+ (vconcat uim-translated-key-vector translated))
+ (setq uim-untranslated-key-vector nil))
- (if current-prefix-arg
- (setq uim-prefix-arg current-prefix-arg))
+ (map
+ (setq wait t)
+ )
-
- (if uim-prefix-arg
- (uim-debug (format "uim-prefix-arg %s" uim-prefix-arg)))
-
- (if uim-xemacs
- (setq uim-original-input-event (copy-event last-input-event)))
-
- (let ((keyvec (uim-this-command-keys current-prefix-arg))
- sendkey newvec bypass count mouse)
-
- (if uim-prefix-arg
- (setq current-prefix-arg uim-prefix-arg))
-
- (if keyvec
- (progn
- (if uim-show-keystrokes
- (let (message-log-max)
- (message (key-description keyvec))))
-
- (setq uim-last-key-vector keyvec)
-
- (cond (uim-xemacs
- ;; XEmacs ;;
- (setq sendkey
- (uim-convert-keystr-to-uimagent-vector (key-description
keyvec)))
-
- (cond ((string-match "button\\(1\\|2\\|3\\|4\\|5\\)"
- (key-description keyvec))
- ;; through mouse event
- (setq mouse t)
- (setq bypass t))
-
- (current-prefix-arg
- (setq bypass t)
- ;;(setq count (prefix-numeric-value arg))
- (setq count (prefix-numeric-value current-prefix-arg))
- (uim-debug (format "with prefix arg: count is %s"
count))
- )
-
- ((and (not (or uim-preedit-displayed
- uim-candidate-displayed))
- (uim-buffer-not-editable))
- ;; through uim-el-agent when buffer is uneditable
- (setq bypass t)
- ))
-
- (if bypass
- (setq sendkey
- (uim-convert-char-to-symbolvector
- (key-description keyvec))))
- )
+ (t
+ (setq send t)
+ )
+ ))
+ (when (not non-error)
+ (setq uim-translated-key-vector nil)
+ (setq uim-untranslated-key-vector nil)
+ (setq uim-prefix-arg nil)
+ (setq uim-prefix-arg-vector nil)
+ (signal 'quit nil)
+ )))
+
+ (when send
+
+ (uim-debug "pre-SEND")
+
+ (setq send-vector-raw (vconcat uim-translated-key-vector
+ uim-untranslated-key-vector))
+
+ (setq send-vector
+ (if uim-emacs
+ send-vector-raw
+ (if uim-xemacs
+ (uim-convert-keystr-to-uimagent-vector (key-description
send-vector-raw))
+ nil)))
+
+ (uim-debug (format "send-vector: %s" send-vector))
+ (uim-debug (format "send-vector-raw: %s" send-vector-raw))
+
+
+ (cond ((or (and uim-emacs
+ (eventp event)
+ (memq (event-basic-type event)
+ '(mouse-1 mouse-2 mouse-3 mouse-4 mouse-5)))
+ (and uim-xemacs
+ (string-match "button\\(1\\|2\\|3\\|4\\|5\\)"
+ (key-description send-vector-raw))))
+ (uim-debug "mouse event")
+ (setq send nil)
+ (setq mouse t))
+
+ ((or (and uim-preedit-keymap-enabled
+ (not window-system)
+ (not uim-use-single-escape-on-terminal)
+ (uim-is-single-escape send-vector-raw)))
+ (uim-debug "half escape found")
+ (setq send nil)
+ (setq wait t))
+
+ (current-prefix-arg
+ (setq send nil)
+ (setq issue t))
+
+ ((or (eq (car-safe (aref send-vector 0)) 'menu-bar)
+ (eq (car-safe (aref send-vector 0)) 'tool-bar))
+ (setq send nil)
+ (if (not uim-preedit-keymap-enabled)
+ (setq issue t)
+ (if (and uim-preedit-keymap-enabled
+ (keymapp (uim-key-binding send-vector)))
+ (setq wait t)
+ (setq discard t))))
+
+ ((and (or (>= (length send-vector) 3)
+ (and (= (length send-vector) 2)
+ (not (or (eq (aref send-vector 0) 27)
+ (eq (aref send-vector 0) 'escape))))))
+ (uim-debug "too long vector")
+ (setq send nil)
+ (if (not uim-preedit-keymap-enabled)
+ (setq issue t)))
+
+ ))
+
+
+
+ (when send
+ ;; uim-el-agent
+
+ (uim-debug "SEND")
+
+ ;;(setq uim-last-key-vector send-vector)
+ (setq uim-last-key-vector send-vector-raw)
+
+ (when uim-emacs
+ (cond ((equal send-vector [127]) (setq send-vector [backspace]))
+ ((equal send-vector [27 27]) (setq send-vector [27]))
+ ((equal send-vector [28]) (setq send-vector [C-\\]))
+ ((equal send-vector [29]) (setq send-vector [C-\]]))
+ ((equal send-vector [30]) (setq send-vector [C-~]))
+ ((equal send-vector [31]) (setq send-vector [C-_]))
+ ))
+
+ (when uim-xemacs
+
+ (uim-debug (format "send-vector-raw1.5: %s" send-vector-raw))
+
+ (if (equal (make-vector 2 (uim-xemacs-make-event [(escape)]))
+ send-vector-raw)
+ (setq send-vector-raw
+ (vector (uim-xemacs-make-event [(escape)]))))
+
+ (setq send-vector-raw (uim-translate-escape-meta send-vector-raw))
+
+ (uim-debug (format "send-vector-raw2: %s" send-vector-raw))
+
+ (setq send-vector
+ (uim-convert-keystr-to-uimagent-vector
+ (key-description send-vector-raw))))
+
+ (uim-debug (format "send:%s issue:%s wait:%s mouse:%s"
+ send issue wait mouse))
+
+ (unwind-protect
+ (progn
+ (setq uim-wait-next-key nil)
+ (uim-do-send-recv-cmd (format "%d %s"
+ uim-context-id send-vector))
+ (setq wait uim-wait-next-key)
- (uim-emacs
- ;; Emacs ;;
- (setq sendkey keyvec)
-
- (cond (current-prefix-arg
- (setq bypass t)
- (setq count (prefix-numeric-value arg))
- (setq count (prefix-numeric-value current-prefix-arg))
- (uim-debug (format "with prefix arg: count is %s"
- count))
- )
- ((and (eventp event)
- (memq (event-basic-type event)
- '(mouse-1 mouse-2 mouse-3 mouse-4 mouse-5)))
- ;; detect mouse event
- ;;(uim-debug "mouse event")
- (setq bypass t)
- (setq mouse t)
- )
- ((and (not (or uim-preedit-displayed
- uim-candidate-displayed))
- (uim-buffer-not-editable))
- (setq bypass t))
- (t
- ;; overwrite special keyvector
- (cond ((equal sendkey [127]) (setq sendkey
[backspace]))
- ((equal sendkey [27 27]) (setq sendkey [27]))
- ((equal sendkey [28]) (setq sendkey [C-\\]))
- ((equal sendkey [29]) (setq sendkey [C-\]]))
- ((equal sendkey [30]) (setq sendkey [C-~]))
- ((equal sendkey [31]) (setq sendkey [C-_]))
- ))
- )
- ))
-
- ;; pass only Uim supported keys
- (when (or (>= (length sendkey) 3)
- (and (= (length sendkey) 2)
- (not (or (eq (aref sendkey 0) 27)
- (eq (aref sendkey 0) 'escape)))))
- (uim-debug "bypass")
- (setq bypass t))
-
-
- (unwind-protect
- (if (and uim-preedit-keymap-enabled
- (or (eq (car-safe (aref sendkey 0)) 'menu-bar)
- (eq (car-safe (aref sendkey 0)) 'tool-bar)))
- (uim-do-send-recv-cmd (format "%d NOP" uim-context-id))
- (if (not bypass)
- (uim-do-send-recv-cmd (format "%d %s" uim-context-id
sendkey))
- (if mouse
- (uim-process-mouse-event event)
- (uim-process-keyvec uim-last-key-vector count)
-
- ;; display "ESC ESC ESC" or something
-
- (if uim-show-keystrokes
- (let (message-log-max keymsg)
- (setq keymsg (if uim-prefix-arg-vector
- (concat (key-description
uim-prefix-arg-vector)
- " ")
- nil))
- (mapcar '(lambda (x)
- (setq keymsg (concat keymsg
- (key-description
(vector x))
- " ")))
- (append uim-last-key-vector nil))
- (message keymsg))
- )
- )))
-
- (progn
- (uim-debug "reset prefix variables")
- (setq uim-prefix-arg nil)
- (setq uim-prefix-arg-vector nil)
- (setq uim-prefix-ignore-next nil)
- )
- )
+ (uim-debug "send-recv done"))
- )
+ (when (not uim-wait-next-key)
+ (uim-debug "* reset parameter after send")
+ (setq uim-translated-key-vector nil)
+ (setq uim-untranslated-key-vector nil)
+ (setq uim-prefix-arg nil)
+ (setq uim-prefix-arg-vector nil)
+ )))
+
+ (when mouse
+ (unwind-protect
+ (uim-process-mouse-event event)
+ (uim-debug "* reset parameter after mouse")
+ (setq uim-translated-key-vector nil)
+ (setq uim-untranslated-key-vector nil)
+ (setq uim-prefix-arg nil)
+ (setq uim-prefix-arg-vector nil)
+ ))
+
+
+ (when issue
+
+ (let (issue-vector-raw)
+ (setq issue-vector-raw (vconcat uim-translated-key-vector
+ uim-untranslated-key-vector))
+
+ (setq issue-vector
+ (if uim-emacs
+ issue-vector-raw
+ (if uim-xemacs
+ (uim-convert-char-to-symbolvector
+ (key-description issue-vector-raw)))))
- ;; if keyvec is nil
- (setq uim-deactivate-mark nil)
+ (setq uim-last-key-vector issue-vector-raw)
+
+ (uim-debug (format "issue-vector-raw: %s" issue-vector-raw))
- (if (not uim-show-keystrokes)
- (if (sit-for echo-keystrokes)
- (setq uim-show-keystrokes t)))
+ (unwind-protect
+ (let (count)
+ (if uim-prefix-arg
+ (setq count (prefix-numeric-value uim-prefix-arg)))
+
+ (uim-debug (format "issue command %s %s"
+ issue-vector-raw count))
+
+ (if (uim-process-keyvec issue-vector-raw count)
+ (setq wait t)))
+ (when (not wait)
+ (uim-debug "* reset parameter after issue")
+ (setq uim-translated-key-vector nil)
+ (setq uim-untranslated-key-vector nil)
+ (setq uim-prefix-arg nil)
+ (setq uim-prefix-arg-vector nil)
+ ))))
+
+
+ (when wait
+ (uim-debug "wait next input")
+
+
+ (if (and (memq last-command (list 'universal-argument
+ 'digit-argument
+ 'negative-argument))
+ (current-message))
+ (setq uim-keystroke-displaying t))
+
+ (if (not uim-keystroke-displaying)
+ (setq uim-keystroke-displaying (sit-for echo-keystrokes)))
+
+ (uim-debug (format "*** uim-keystroke-displaying: %s"
+ uim-keystroke-displaying))
+
;; display "ESC-" or something
- (if uim-show-keystrokes
+ ;;(uim-debug (format "uim-prefix-arg-vector2 %s" uim-prefix-arg-vector))
+ (if uim-keystroke-displaying
(let (message-log-max)
- (message (concat (key-description (vconcat uim-prefix-arg-vector
- uim-stacked-key-vector))
+ (uim-debug (format "uim-translated-key-vector %s"
+ uim-translated-key-vector))
+ (message (concat (key-description
+ (vconcat uim-prefix-arg-vector
+ (if uim-xemacs
+ (uim-translate-escape-meta
uim-translated-key-vector)
+ uim-translated-key-vector)
+ (if uim-xemacs
+ (uim-translate-escape-meta
uim-untranslated-key-vector)
+ uim-untranslated-key-vector)
+
+ ))
+ (if uim-xemacs " ")
"-"))))
- ))
+
+ (if uim-emacs
+ (setq uim-deactivate-mark nil))
+
+ )
+
+ (when discard
+ (uim-debug "discard input")
+ (unwind-protect
+ nil
+ (setq uim-translated-key-vector nil)
+ (setq uim-untranslated-key-vector nil)
+ (setq uim-prefix-arg nil)
+ (setq uim-prefix-arg-vector nil)
+ ))
+
+;; display "ESC ESC ESC" or something
+ (when (and (or send issue)
+ (not wait)
+ uim-keystroke-displaying)
+
+ (uim-debug (format "update final message %s" uim-last-key-vector))
+
+ (let (message-log-max msg)
+ (setq msg (if uim-prefix-arg-vector
+ (concat " " (key-description uim-prefix-arg-vector) " ")
+ ""))
+
+ (mapcar '(lambda (x)
+ (setq msg (concat msg
+ (key-description (vector x)) " ")))
+
+ (append (if uim-xemacs
+ (uim-translate-escape-meta send-vector-raw)
+ uim-last-key-vector) nil))
+ (message msg)))
+
+ )
(if uim-emacs
(setq deactivate-mark uim-deactivate-mark))
@@ -1060,7 +1206,7 @@
;; process return expression from uim-el-agent
(defun uim-process-agent-output (str)
(catch 'process-agent-output
- (let (;;(inhibit-quit t)
+ (let ((inhibit-quit t)
preedit-existed
candidate-existed
key commit preedit candidate default im label imlist helpermsg
@@ -1172,6 +1318,7 @@
;; disable buffer-undo temporarily
(when uim-buffer-undo-list-saved
+
(setq buffer-undo-list (uim-delete-atom buffer-undo-list))
(setq uim-buffer-undo-list
@@ -1201,8 +1348,16 @@
;; C-o is also processed here ... orz
(let ((inhibit-read-only t))
(unwind-protect
- (progn
- (uim-process-keyvec key)
+ (let (count)
+ (uim-debug (format "uim-prefix-arg: %s" uim-prefix-arg))
+ (if uim-prefix-arg
+ (setq count (prefix-numeric-value uim-prefix-arg)))
+
+ (when (uim-process-keyvec key count)
+ ;;(setq uim-stacked-key-vector key)
+ (setq uim-wait-next-key t)
+ ;;(setq uim-prefix-arg count)
+ )
(setq keyproc-done t))
(when (not keyproc-done)
(uim-leave-preedit-mode)
