Suggest `M-\' feature for addition and related input issue.

I would like to suggest another feature for addition, the `M-\'.

You may probably know that there are possibly more that one hundred input 
methods in Chinese, categoried into two paradigms:

1. Input by pronounciation: Since most Chinese can ``correctly'' pronounce 
their language through elementary education, therefore even most unusually 
used words they haven't seen before, they could guess how the words are 
pronounced and input them in most cases.  BUT this kind of input methods 
is much slower since there are too many words with the same 
pronounciation.  (for example, `chinese-zozy')

2. Input by `spelling customized radicals' of a word: This kind is a much 
faster way to input, since every word has its own shape.  You could almost 
input a Chinese word without choose it from the conflict list.  (for 
example, `chinese-array30' that I'm using)

Now here is the idea:

1. Most of the time `spelling' is a good way to input since it is fast, 
then we make `array30' for example as the ``primary'' input method.

2. Sometimes `spelling' is invalid since it's not a part of elementary 
education, then we use `zozy' for example, as a thorough but slower way to 
input, as ``secondary'' input method.

3. So I put the following lines into `.emacs' to set `array30' as my 
default input method:

(custom-set-variables
' (default-input-method "chinese-array30"))

Now I can toggle input method between `English' and `array30' by `C-\'.

4. However, when I cannot spell a word by `array30', I must change input 
method by C-x RET C-\ and type `chinese-zozy' for this purpose, and change 
it back will be another similar procedure, although this time I do not 
need to type again since Emacs has set it as a default choice.  This means 
that toggling between Chinese input methods has no easy way to do, `C-x 
RET C-\' is always required.  So I suggest `M-\' to complement this idea.

That is:

Toggling between English and Chinese (or others) input methods by `C-\';
toggling among user-specified (Chinese) input methods by `M-\'.

And the lines in `.emacs' might be: (pseudo code)

(custom-set-variables '(default-input-method "chinese-array30"))
(custom-set-variables '(alternate-input-method "chinese-zozy"))
(custom-set-variables '(alternate-input-methos "chinese-4corner"))

Noted that alternate-input-method could be plural, and together with
default-input-method comprise the whole user-specified input methods.  
Using `M-\' would change among user-specified input methods in a rotary 
fashion, `C-\' would change input method to `English' and another `C-\' 
would change input method back to formerly used user-specified input 
method, whether it's default or alternate.

And here is a BUG-report and suggesion related to mule input:

While inputing a word with three customized radicals via mule, these 
three radicals will appear one by one at the left of minibuffer when I 
keyin.  But after typing SPACE, that makes a word being inputted, the 
radicals are gone, leaving the minibuffer a blank:

1. The BUG is: if there are two windows in Emacs with different input 
methods, and if I'm inputing words in the above one, the minibuffer shows 
`radicals' of the input method that the below one is using.  To correct 
this problem, you may need to set the showing of radicals to go accord 
with the active window, i.e. the window that is now being editing.

2. Leaving a blank after a word is being inputted is a waste, I would like 
to suggest that after a word is being inputted, minibuffer would show the 
`radicals' of `primary' (i.e. the default-input-method) of that word.  
With this feature, I could read the information of how to spell a word in 
`array30' (my primary input method) while using `zozy' or other input 
methods, and this is the difference between default-input-method and 
alternate-input-method.

I guess this feature is also useful in other languages...

Sorry that I don't provide the information in a concise way, but hopefully 
this would convince you that the suggested features are Emacs should-have 
ones.

And do you have any information on how to prepare an input method in 
Emacs?  I would like to draw more people to port their favorate input 
methods into Emacs, and I'm also interested in porting array30 for 
simplified Chinese and Japanese if possible.