Changeset 3998

Timestamp:

12/14/05 00:17:42 (2 years ago)

Author:

horiguti

Message:

Change around IME control.

Files:

• trunk/lisp/ChangeLog.Meadow (modified) (1 diff)
• trunk/lisp/international/meadow.el (modified) (11 diffs)
• trunk/src/ChangeLog.Meadow (modified) (2 diffs)
• trunk/src/mw32fns.c (modified) (2 diffs)
• trunk/src/mw32ime.c (modified) (18 diffs)
• trunk/src/mw32term.c (modified) (2 diffs)
• trunk/src/mw32term.h (modified) (1 diff)

trunk/lisp/ChangeLog.Meadow

@@ +1 @@
+2005-12-13  Kyotaro HORIGUCHI  <horiguti@meadowy.org>
+
+        * international/meadow.el (mw32-ime-cont-on): New variable.
+        (mw32-input-method-noconv-regexp): New variable.
+        (mw32-set-ime-if-available): Initialize MW32-IME.
+        (mw32-ime-sync-state): Changed.
+        (mw32-ime-mode-line-update): Remove redundant parameter.
+        (mw32-ime-initialize): Ressurected. Change doc string. Add
+        treatment for isearch.
+        (mw32-ime-uninitialize): Add treatment for isearch.
+        (mw32-isearch-mode-hook-function): New hook function.
+        (mw32-ime-state-switch): Move IME initialization into
+        mw32-ime-initialize.
+        (): Change registration of MW32-IME.
+        (mw32-input-method): New function to be used for
+        input-method-function.
+
-2005-11-26  MIYOSHI Masanori  <miyoshi@meadowy.org>
-

trunk/lisp/international/meadow.el

@@ -1 @@
-;;;;; meadow.el ---- For Meadow.
-;;
-;;   Author H.Miyashita
@@ -155 +154 @@
-(defvar mw32-ime-mode-line-format-original nil
-  "Original mode line format.")
+(defvar mw32-ime-cont-on t
+  "It not nil, IME is always on during current-input-method is MW32-IME.")
+(defvar mw32-input-method-noconv-regexp nil
+  "Regexp represents printable-chars that does not activate IME.")
-
-(setq search-highlight t)
@@ -267 +270 @@
-    (when (and ime (mw32-ime-available))
-        (setq default-input-method (cdr ime))
+        (mw32-ime-initialize)
-        (define-key global-map [kanji] 'toggle-input-method))))
-
@@ -327 +331 @@
-  (when mw32-ime-buffer-switch-p
-    (with-current-buffer (window-buffer window)
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-
-(defun mw32-ime-set-selected-window-buffer-hook (oldbuf newwin newbuf)
@@ -349 +352 @@
-  (cond
-   (mw32-ime-show-mode-line
- (selected-window)
+
-      (setq mw32-ime-mode-line-state-indicator
-            (nth (if (fep-get-mode) 1 2)
@@ -384 +387 @@
-
-(defun mw32-ime-initialize ()
-
-
+
-  (cond
-   ((and (eq system-type 'windows-nt)
@@ -397 +399 @@
-      (mw32-ime-init-mode-line-display)
-      (mw32-ime-mode-line-update)
-
-
+
-      (add-hook 'set-selected-window-buffer-functions
-                'mw32-ime-set-selected-window-buffer-hook)
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-(defun mw32-ime-uninitialize ()
-  (cond ((and (eq system-type 'windows-nt)
@@ -415 +430 @@
-                      'mw32-ime-select-window-hook)
-         (remove-hook 'set-selected-window-buffer-functions
-
-
+
+
+
+
+
-(defun mw32-ime-exit-from-minibuffer ()
-  (inactivate-input-method)
@@ -423 +441 @@
-
-(defun mw32-ime-state-switch (&optional arg)
+  (kill-local-variable 'input-method-function)
+  (if (fep-get-mode)
+      (fep-force-off))
-  (if arg
-      (progn
-        (when (null (memq 'mw32-ime-select-window-hook
-                          select-window-functions))
-
-
-
-
-
+
-        (setq inactivate-current-input-method-function
-              'mw32-ime-state-switch)
@@ -437 +454 @@
-        (run-hooks 'mw32-ime-on-hook)
-        (setq describe-current-input-method-function nil)
-eq (selected-window) (minibuffer-window)
+window-minibuffer-p
-          (add-hook 'minibuffer-exit-hook 'mw32-ime-exit-from-minibuffer))
-
+
+
+
+
+
-    (setq current-input-method nil)
-    (run-hooks 'input-method-inactivate-hook)
-    (run-hooks 'mw32-ime-off-hook)
-
-
+
-  (mw32-ime-mode-line-update))
-
-
+A‚ 
-                       "MW32 System IME")
-
@@ -493 +513 @@
-          (t 'static-color))))
-
+(defun mw32-input-method (key)
+  "Input method function for IME."
+  (if (or
+       (let ((case-fold-search nil))
+         (and key
+              mw32-input-method-noconv-regexp
+              (string-match mw32-input-method-noconv-regexp
+                            (char-to-string key))))
+       (fep-get-mode))
+      (list key)
+    (sit-for 0)
+    (fep-force-on)
+        (let* ((pos (point))
+               (ov (make-overlay (point) (1+ (point))))
+               (ret (mw32-ime-input-method-function (char-to-string key)))
+               (result (append (car ret) nil)))
+      ;;; Continue to conversion if composition string cannot be
+      ;;; convert into single ascii character.
+          (unwind-protect
+              (while (or
+                      (> (length (cadr ret)) 1)
+                      (and
+                       (cadr ret)
+                       (not (eq (string-to-char (japanese-hankaku (cadr ret)))
+                                (caddr ret)))))
+                (insert (car ret))
+                (move-overlay ov pos (point))
+                (if input-method-highlight-flag
+                    (overlay-put ov 'face 'underline))
+                (sit-for 0)
+                (setq ret (mw32-ime-input-method-function))
+                (setq result (append result (append (car ret) nil))))
+            (if (and (cadr ret)
+                     (eq (length (cadr ret)) 1)
+                     (eq (string-to-char (japanese-hankaku (cadr ret)))
+                         (caddr ret)))
+                (setq unread-input-method-events
+                      (cons (caddr ret) unread-input-method-events)))
+            (fep-force-off)
+            (delete-region pos (point))
+            (delete-overlay ov))
+          result)))
+
-;; dummy vals.
-(defun x-server-max-request-size (&optional display) 65535)

trunk/src/ChangeLog.Meadow

@@ +1 @@
+2005-12-13  Kyotaro HORIGUCHI  <horiguti@meadowy.org>
+
+        * mw32ime.c (IMMGETVIRTUALKEYPROC): New typedef.
+        (ImmGetVirtualKeyProc): New function pointer.
+        (input_method_function_event): New event object.
+        (waiting_on_main_thread): New variable.
+        (input_method_function_string): New variable.
+        (last_ime_keycode): New variable.
+        (last_ime_keymod): New variable.
+        (mw32_ime_get_virtual_key): New function.
+        (mw32_ime_record_keycode): New function.
+        (mw32_ime_set_composition_string): New function.
+        (mw32_get_ime_composition_string): Renamed to
+        mw32_get_ime_result_string. Add process for
+        mw32-ime-input-method-function.
+        (mw32_ime_get_composition_string): New function.
+        (mw32_ime_control_init): Initialize ImmGetVirtualKeyProc and
+        input_method_function_event.
+        (conversion_agent_wndproc<WM_MULE_IMM_GET_COMPOSISION_STRING>):
+        Message renamed to WM_MULE_IMM_GET_RESULT_STRING and ditto about
+        the calling function.
+        (mw32_ime_cancel_input_function): New function.
+        (mw32-ime-input-method-function): New lisp function.
+        (fep-force-on): Detail doc string.
+        (fep-force-off): Ditto.
+        (cmode_list): New static data for imm-get-conversion-status.
+        (imm-get-conversion-status): New lisp function.
+        (w32-set-ime-mode): Changed.
+
+        * mw32term.c (mw32_message_loop<WM_KEYDOWN>): Record virtual
+        keycode of VK_PROCESSKEY.
+        (mw32_message_loop<WM_MULE_IME_REPORT>): Don't enter the loop when
+        lpStr is null.
+
+        * mw32term.h (WM_MULE_IMM_GET_RESULT_STRING): New symbol.
+        (WM_MULE_IMM_GET_SET_MODE): Numerical ID is shifted.
+
+        * mw32fns.c (mw32_WndProc<WM_IME_COMPOSITION>):
+        mw32_get_ime_composition_string() is renamed to
+        mw32_get_ime_result_string(). Cancel input method function when no
+        composition string is left.
+        (mw32_WndProc<WM_WM_MULE_IMM_SET_COMPOSITION_STRING>): New message
+        handler.
+        (mw32_WndProc<WM_WM_MULE_IMM_GET_COMPOSITION_STRING>): New message
+        handler.
+
-2005-12-13  Kyotaro HORIGUCHI  <horiguti@meadowy.org>
-
@@ -73 +119 @@
-        (set-window-configuration): Ditto.
-
+        * eval.c (signal): Remove W32_UNBLOCK_INPUT.
+        
-2005-12-01  MIYOSHI Masanori  <miyoshi@meadowy.org>
-

trunk/src/mw32fns.c

@@ -2448 +2448 @@
-      if (lParam & GCS_RESULTSTR)
-        {
-composion
-composition
+result
+result
-            return 0;
-          else
-            break;
-        }
+      
+      if (mw32_get_ime_undetermined_string_length (hwnd) == 0)
+        { /* Cancelling composition string */
+          mw32_ime_cancel_input_function ();
+        }       
+      
-      goto dflt;
-    }
@@ -2503 +2509 @@
-    mw32_set_ime_conv_window (hwnd, (struct window *) wParam);
-    break;
+
+  case WM_MULE_IMM_SET_COMPOSITION_STRING:
+    mw32_ime_set_composition_string (hwnd, (char*) wParam);
+    break;
+
+  case WM_MULE_IMM_GET_COMPOSITION_STRING:
+    mw32_ime_get_composition_string (hwnd);
+    break;
+
-#endif /* not MEADOW and IME_CONTROL */
-

trunk/src/mw32ime.c

@@ -144 +144 @@
-typedef BOOL (WINAPI *IMMISIMEPROC)(HKL);
-IMMISIMEPROC ImmIsIMEProc;
+typedef UINT (WINAPI *IMMGETVIRTUALKEYPROC)(HWND);
+IMMGETVIRTUALKEYPROC ImmGetVirtualKeyProc;
-
-extern Lisp_Object Vime_control;
-
-static WPARAM wIMEOpen;
+
+static HANDLE input_method_function_event = INVALID_HANDLE_VALUE;
+static int waiting_on_main_thread = FALSE;
+static HANDLE input_method_function_string = INVALID_HANDLE_VALUE;
-
-Lisp_Object Vime_control;
@@ -153 +159 @@
-Lisp_Object Qim_info;
-
-
-int IME_event_off_count;
+static int last_ime_vkeycode;
+static int last_ime_vkeymod;
+
+int
+mw32_ime_get_virtual_key (HWND hwnd)
+{
+  return (ImmGetVirtualKeyProc)(hwnd);
+}
+
+void
+mw32_ime_record_keycode (int keycode, int keymod)
+{
+  last_ime_vkeycode = keycode;
+  last_ime_vkeymod  = keymod;
+}
-
-void
@@ -185 +205 @@
-
-void
+mw32_ime_set_composition_string (HWND hwnd, char* str)
+{
+  HIMC himc;
+
+  himc = (ImmGetContextProc) (hwnd);
+  (ImmSetCompositionStringProc) (himc, SCS_SETSTR, str, strlen (str), NULL, 0);
+  (ImmReleaseContextProc) (hwnd, himc);
+}
+
+void
-mw32_set_ime_status (HWND hwnd, int openp)
-{
@@ -240 +270 @@
-
-BOOL
-composition
+result
-{
-  HIMC hIMC;
@@ -254 +284 @@
-  size = (ImmGetCompositionStringProc) (hIMC, GCS_RESULTSTR, NULL, 0);
-  size += sizeof (TCHAR);
-
+
+
-  if (!himestr) abort ();
-  lpstr = GlobalLock (himestr);
@@ -260 +291 @@
-  (ImmGetCompositionStringProc) (hIMC, GCS_RESULTSTR, lpstr, size);
-  (ImmReleaseContextProc) (hwnd, hIMC);
+  lpstr [size-1] = 0;
-  GlobalUnlock (himestr);
-
-
-
+
+
+
+
+
+
+
+
+
-  return TRUE;
-}
-
+BOOL
+mw32_ime_get_composition_string (HWND hwnd)
+{
+  HIMC hIMC;
+  int size;
+  HANDLE himestr;
+  LPSTR lpstr;
+  struct frame *f;
+  struct mw32_display_info *dpyinfo = GET_MW32_DISPLAY_INFO (hwnd);
+
+  hIMC = (ImmGetContextProc) (hwnd);
+  if (!hIMC) return FALSE;
+
+  size = (ImmGetCompositionStringProc) (hIMC, GCS_COMPSTR, NULL, 0);
+  size += sizeof (TCHAR);
+
+  input_method_function_string = himestr = GlobalAlloc (GHND, size);
+  if (!himestr) abort ();
+  lpstr = GlobalLock (himestr);
+  if (!lpstr) abort ();
+  (ImmGetCompositionStringProc) (hIMC, GCS_COMPSTR, lpstr, size);
+  (ImmReleaseContextProc) (hwnd, hIMC);
+  lpstr [size-1] = 0;
+  GlobalUnlock (himestr);
+
+  if (waiting_on_main_thread)
+    SetEvent (input_method_function_event);
+  else
+    {
+      f = mw32_window_to_frame (dpyinfo, hwnd);
+      PostMessage (NULL, WM_MULE_IME_REPORT,
+                   (WPARAM) himestr, (LPARAM) f);
+    }   
+  return TRUE;
+}
+
-#ifdef IME_RECONVERSION
-
+
+
-int
-mw32_get_ime_reconversion_string (HWND hwnd, WPARAM wParam,
@@ -474 +549 @@
-        GetProcAddress (hImm32,
-                        "ImmGetHotKey");
-
-      ImmIsIMEProc =
-        (IMMISIMEPROC)
-        GetProcAddress (hImm32,
-                        "ImmIsIME");
-
+
+
+
+
-      if (ImmGetOpenStatusProc &&
-          ImmSetOpenStatusProc &&
@@ -499 +576 @@
-          ImmGetCandidateListCountProc &&
-          ImmGetHotKeyProc &&
-
+
+
-        {
-          fIME = TRUE;
-          Vime_control = Qt;
+          input_method_function_event = CreateEvent (NULL, FALSE, FALSE, NULL);
-        }
-    }
@@ -592 +671 @@
-#endif
-
-COMPOSITION
-composition
+RESULT
+result
-
-    case WM_MULE_IMM_NOTIFY:
@@ -709 +788 @@
-}
-
+void
+mw32_ime_cancel_input_function (void)
+ {
+   waiting_on_main_thread = FALSE;
+   
+  if (input_method_function_string != INVALID_HANDLE_VALUE)
+      GlobalFree (input_method_function_string);
+
+  input_method_function_string = INVALID_HANDLE_VALUE;
+  
+  SetEvent (input_method_function_event);
+}       
+
+Lisp_Object mw32_ime_input_method_function_unwind (arg)
+  Lisp_Object arg;
+{
+  mw32_ime_cancel_input_function ();
+
+  if (NILP (arg))
+    Ffep_force_off ();
+
+  return Qnil;
+}
-
-
@@ -714 +816 @@
-  Emacs Lisp function entries
-*/
+
+
+DEFUN ("mw32-ime-input-method-function",
+       Fmw32_ime_input_method_function, Smw32_ime_input_method_function,
+       0, 1, 0, doc: /* Low level input method function for IME.
+STR is initial composition string.
+Returns (RESULTSTR COMPSTR LASTCHAR) where RESULTSTR is the conversion result
+string, COMPSTR is the composition string left behind in conversion, and
+LASTCHAR is the keycode of the last input during conversion. */)
+  (str)
+{
+  HWND hwnd;
+  int count = SPECPDL_INDEX ();
+  Lisp_Object resultstr, compstr, result;
+  struct frame *f;
+  struct mw32_display_info *dpyinfo;
+  HANDLE hstr;
+
+  hwnd = FRAME_MW32_WINDOW (XFRAME (selected_frame));
+  dpyinfo = GET_MW32_DISPLAY_INFO (hwnd);
+  f = mw32_window_to_frame (dpyinfo, hwnd);
+
+  record_unwind_protect (mw32_ime_input_method_function_unwind,
+                         Ffep_get_mode ());
+  waiting_on_main_thread = TRUE;
+  ResetEvent (input_method_function_event);
+
+  result = Qnil;
+  Ffep_force_on ();
+
+  /* If new ascii (expected..) key event comes after this function
+     invoked, get it and add to composition string. */
+  if (kbd_buffer_events_waiting (0))
+    {
+      Lisp_Object kseq, args[2];
+
+      kseq = call5 (intern ("read-key-sequence"), Qnil, Qnil, Qnil, Qnil, Qnil);
+      if (STRINGP (kseq))
+        {
+          args[0] = str;
+          args[1] = kseq;
+          str = Fconcat (2, args);
+        }
+    }
+  fflush (stdout);
+  if (STRINGP (str))
+    {
+      str = ENCODE_SYSTEM (str);
+      SendMessage (hwnd, WM_MULE_IMM_SET_COMPOSITION_STRING,
+                   (WPARAM)(SDATA (str)), 0);
+    }
+
+  mw32_set_ime_conv_window (hwnd,
+                            cursor_in_echo_area ?
+                            XWINDOW (f->minibuffer_window):
+                            XWINDOW (f->selected_window));
+
+  /* Rescue from dead block. This may not happen. */
+  while (WaitForSingleObject (input_method_function_event, 500L)
+         == WAIT_TIMEOUT)
+    QUIT;
+
+  hstr = input_method_function_string;
+  input_method_function_string = INVALID_HANDLE_VALUE;
+  resultstr = compstr = result = Qnil;
+  
+  if (hstr != INVALID_HANDLE_VALUE)
+    {
+      char* str = GlobalLock (hstr);
+      if (str)
+        {
+          resultstr = make_string (str, strlen (str));
+          resultstr = DECODE_SYSTEM (resultstr);
+        }       
+      
+      GlobalUnlock (hstr);
+      GlobalFree (hstr);
+    }
+
+  waiting_on_main_thread = TRUE;
+  ResetEvent (input_method_function_event);
+
+  SendMessage (hwnd, WM_MULE_IMM_GET_COMPOSITION_STRING, 0, 0);
+  while (WaitForSingleObject (input_method_function_event, 500L)
+         == WAIT_TIMEOUT)
+    QUIT;
+
+  if (hstr != INVALID_HANDLE_VALUE)
+    {
+      char* str = GlobalLock (hstr);
+      if (str)
+        {
+          compstr = make_string (str, strlen (str));
+          compstr = DECODE_SYSTEM (compstr);
+        }       
+      
+      GlobalUnlock (hstr);
+      GlobalFree (hstr);
+    }
+
+  result = Fcons (resultstr,
+                  Fcons (compstr,
+                         Fcons (make_number (last_ime_vkeymod ? 0
+                                             : last_ime_vkeycode),
+                                Qnil)));
+
+  return unbind_to (count, result);
+}
-
-DEFUN ("mw32-ime-available", Fmw32_ime_available, Smw32_ime_available,
@@ -735 +945 @@
-
-DEFUN ("fep-force-on", Ffep_force_on, Sfep_force_on, 0, 1, 0,
-
+
+
-  (eventp)
-     Lisp_Object eventp;
@@ -741 +952 @@
-  if (fIME && !NILP (Vime_control))
-    {
-      HIMC himc;
-      HWND hwnd;
-
@@ -759 +969 @@
-
-DEFUN ("fep-force-off", Ffep_force_off, Sfep_force_off, 0, 1, 0,
-
+
+
-  (eventp)
-     Lisp_Object eventp;
@@ -765 +976 @@
-  if (fIME && !NILP (Vime_control))
-    {
-      HIMC himc;
-      HWND hwnd;
-
@@ -831 +1041 @@
-}
-
+  static struct {
+    DWORD mask;
+    char* posi_symbol;
+    char* nega_symbol;
+  } cmode_list[] = {
+    {IME_CMODE_SYMBOL,          "symbol",       "nosymbol"},
+    {IME_CMODE_SOFTKBD,         "softkbd",      "nosoftkbd"},
+    {IME_CMODE_ROMAN,           "roman",        "noroman"},
+    {IME_CMODE_NOCONVERSION,    "noconversion", "conversion"},
+    {IME_CMODE_NATIVE   ,       "native",       "nonative"},
+    {IME_CMODE_KATAKANA,        "katakana",     "nokatakana"},
+    {IME_CMODE_HANJACONVERT,    "hanja",        "nohanja"},
+    {IME_CMODE_FULLSHAPE,       "fullshape",    "halfshape"},
+    {IME_CMODE_FIXED,           "fixed",        "nofixed"},
+    {IME_CMODE_EUDC,            "eudc",         "noeudc"},
+    {IME_CMODE_CHARCODE,        "charcode",     "nocharcode"},
+    /* compatibility */
+    {IME_CMODE_CHARCODE,        "code",         "nocode"},
+    {IME_CMODE_HANJACONVERT,    "kanji",        "nokanji"},
+    {IME_CMODE_KATAKANA,        "katakana",     "hiragana"},
+    {0,                         NULL}
+  };
+  
+
+DEFUN ("imm-get-conversion-status",
+        Fimm_get_conversion_status, Simm_get_conversion_status, 
+       0, 0, 0, doc: /* not documented */)
+  ()
+{
+  DWORD dwConversion, dwSentence;
+  HIMC himc;
+  HWND hwnd;
+  Lisp_Object ret;
+  int i, used;
+
+  if (! fIME ||  NILP (Vime_control))
+    return Qnil;
+
+  hwnd = FRAME_MW32_WINDOW (SELECTED_FRAME ());
+  himc = (ImmGetContextProc) (hwnd);
+  ret = Qnil;
+  used = 0;
+    
+  if (ImmGetConversionStatusProc
+      && ImmGetConversionStatusProc (himc, &dwConversion, &dwSentence))
+    {
+      for (i = 0 ; cmode_list[i].mask ; i++)
+        {
+          if (! (used & cmode_list[i].mask))
+            {
+              used |= cmode_list[i].mask;
+              
+              if (dwConversion & cmode_list[i].mask)
+                ret = Fcons (intern (cmode_list[i].posi_symbol), ret);
+              else
+                ret = Fcons (intern (cmode_list[i].nega_symbol), ret);
+            }
+        }
+    }   
+  
+  (ImmReleaseContextProc) (hwnd, himc);
+  return ret;
+}
+
+
-DEFUN ("w32-set-ime-mode",
-       Fw32_set_ime_mode,
@@ -852 +1127 @@
-    {
-      HWND hwnd;
-
+i, done, 
-      int newmode, mask;
-
-      newmode = 0;
-      mask = 0;
+      done = 0;
+
+      for (i = 0 ; cmode_list[i].mask ; i++)
+        {
+          if (EQ (mode, intern (cmode_list[i].posi_symbol)))
+            {
+              newmode |= cmode_list[i].mask;
+              mask |= cmode_list[i].mask;
+              done = 1;
+            }
+          else if (EQ (mode, intern (cmode_list[i].nega_symbol)))
+            {
+              newmode &= ~cmode_list[i].mask;
+              mask |= cmode_list[i].mask;
+              done = 1;
+            }
+        }
+
+      if (! done)
+        error ("unknown mode!!");
-
-      hwnd = FRAME_MW32_WINDOW (f);
-
-      if (EQ (mode, intern ("katakana")))
-        {
-          newmode |= IME_CMODE_KATAKANA;
-          mask |= IME_CMODE_KATAKANA;
-        }
-      else if (EQ (mode, intern ("hiragana")))
-        {
-          newmode &= ~IME_CMODE_KATAKANA;
-          mask |= IME_CMODE_KATAKANA;
-        }
-      else if (EQ (mode, intern ("kanji")))
-        {
-          newmode |= IME_CMODE_HANJACONVERT;
-          mask |= IME_CMODE_HANJACONVERT;
-        }
-      else if (EQ (mode, intern ("nokanji")))
-        {
-          newmode &= ~IME_CMODE_HANJACONVERT;
-          mask |= IME_CMODE_HANJACONVERT;
-        }
-      else if (EQ (mode, intern ("code")))
-        {
-          newmode |= IME_CMODE_CHARCODE;
-          mask |= IME_CMODE_CHARCODE;
-        }
-      else if (EQ (mode, intern ("nocode")))
-        {
-          newmode &= ~IME_CMODE_CHARCODE;
-          mask |= IME_CMODE_CHARCODE;
-        }
-      else if (EQ (mode, intern ("noconvert")))
-        {
-          newmode |= IME_CMODE_NOCONVERSION;
-          mask |= IME_CMODE_NOCONVERSION;
-        }
-      else if (EQ (mode, intern ("convert")))
-        {
-          newmode &= ~IME_CMODE_NOCONVERSION;
-          mask |= IME_CMODE_NOCONVERSION;
-        }
-      else
-        error ("unknown mode!!");
-
-      ret = SendMessage (hwnd, WM_MULE_IMM_SET_MODE,
-                         (WPARAM) newmode, (LPARAM) mask);
@@ -1582 +1833 @@
-  DEFVAR_LISP ("ime-control", &Vime_control, doc: /* IME control flag  */);
-
+  defsubr (&Simm_get_conversion_status);
+  defsubr (&Smw32_ime_input_method_function);
-  defsubr (&Smw32_ime_available);
-  defsubr (&Smw32_input_language_code);

trunk/src/mw32term.c

@@ -4574 +4574 @@
-              int ocount = count;
-
+              if (msg.wParam == VK_PROCESSKEY)
+                {
+                  int vkey = mw32_ime_get_virtual_key (msg.hwnd);
+                  keyflag =
+                    mw32_emacs_translate_message (dpyinfo, 1, vkey,
+                                                  &keycode, &keymod);
+                  mw32_ime_record_keycode (keycode, keymod);
+                }
-              keyflag = mw32_emacs_translate_message (dpyinfo, 1, msg.wParam,
-                                                      &keycode, &keymod);
@@ -4661 +4669 @@
-              {
-                lpStr = GlobalLock (hw32_ime_string);
-1
+lpStr
-                  {
-                    EVENT_INIT (buf);

trunk/src/mw32term.h

@@ -1000 +1000 @@
-#define WM_MULE_IMM_SET_COMPOSITION_STRING      (WM_USER+2303)
-#define WM_MULE_IMM_GET_COMPOSITION_STRING      (WM_USER+2304)
-
+
+
-#define WM_MULE_IMM_NOTIFY                      (WM_USER+2310)
-#define WM_MULE_IMM_GET_UNDETERMINED_STRING_LENGTH      (WM_USER+2320)