+/* Copyright (C) 2007, 2010
+ National Institute of Advanced Industrial Science and Technology (AIST)
+ Registration Number H15PRO112
+ See the end for copying conditions. */
+
+/***
+
+@page mdbTutorialIM Tutorial of input method
+
+@section im-struct Structure of an input method file
+
An input method is defined in a *.mim file with this format.
+@verbatim
(input-method LANG NAME)
(description (_ "DESCRIPTION"))
(map
(MAP-NAME
- (KEYSEQ MAP-ACTION ...) <- rule
+ (KEYSEQ MAP-ACTION MAP-ACTION ...) <- rule
+ (KEYSEQ MAP-ACTION MAP-ACTION ...) <- rule
+ ...)
+ (MAP-NAME
+ (KEYSEQ MAP-ACTION MAP-ACTION ...) <- rule
+ (KEYSEQ MAP-ACTION MAP-ACTION ...) <- rule
...)
...)
(state
(STATE-NAME
- (MAP-NAME BRANCH-ACTION ...) <- branch
- ...))
+ (MAP-NAME BRANCH-ACTION BRANCH-ACTION ...) <- branch
+ ...)
+ (STATE-NAME
+ (MAP-NAME BRANCH-ACTION BRANCH-ACTION ...) <- branch
+ ...)
+ ...)
+@endverbatim
+Lowercase letters and parentheses are literals, so they must be
+written as they are. Uppercase letters represent arbitrary strings.
KEYSEQ specifies a sequence of keys in this format:
- (SYMBOLIC-KEY ...)
-
-For instance "(n i)" represents a key sequence of <n> and <i>. If all
-SYMBOLIC-KEYs are ASCII characters, you can use the short form "ni".
-
-MAP-ACTION and BRANCH-ACTION are a sequence of actions of this format:
-
- (ACTION ARG ...)
-
-The most common action is "insert" which can be written as this:
-
+@verbatim
+ (SYMBOLIC-KEY SYMBOLIC-KEY ...)
+@endverbatim
+where SYMBOLIC-KEY is the keysym value returned by the xev command.
+For instance
+@verbatim
+ (n i)
+@endverbatim
+represents a key sequence of \<n\> and \<i\>.
+If all SYMBOLIC-KEYs are ASCII characters, you can use the short form
+@verbatim
+ "ni"
+@endverbatim
+instead. Consult @ref mdbIM for Non-ASCII characters.
+
+Both MAP-ACTION and BRANCH-ACTION are a sequence of actions of this format:
+@verbatim
+ (ACTION ARG ARG ...)
+@endverbatim
+The most common action is <tt>insert</tt>, which is written as this:
+@verbatim
(insert "TEXT")
-
-But as it is very frequently used, you can use the short form "TEXT".
-And if "TEXT" actually contains just one character "C", you can write
-as "(insert ?C)" or just "?C". So the shortest notation for an action
-of inserting "a" is "?a".
-
-Here is a simple example:
-
----upcase.mim---------------------------------------------------------
-(input-method en upcase)
+@endverbatim
+But as it is very frequently used, you can use the short form
+@verbatim
+ "TEXT"
+@endverbatim
+If <TT>"TEXT"</TT> contains only one character "C", you can write it as
+@verbatim
+ (insert ?C)
+@endverbatim
+or even shorter as
+@verbatim
+ ?C
+@endverbatim
+So the shortest notation for an action of inserting "a" is
+@verbatim
+ ?a
+@endverbatim
+
+@section im-upcase Simple example of capslock
+
+Here is a simple example of an input method that works as CapsLock.
+
+@verbatim
+(input-method en capslock)
(description (_ "Upcase all lowercase letters"))
(title "a->A")
(map
- (toupper ("a" "A") ("b" "B") ... ("z" "Z")))
+ (toupper ("a" "A") ("b" "B") ("c" "C") ("d" "D") ("e" "E")
+ ("f" "F") ("g" "G") ("h" "H") ("i" "I") ("j" "J")
+ ("k" "K") ("l" "L") ("m" "M") ("n" "N") ("o" "O")
+ ("p" "P") ("q" "Q") ("r" "R") ("s" "S") ("t" "T")
+ ("u" "U") ("v" "V") ("w" "W") ("x" "X") ("y" "Y")
+ ("z" "Z")))
(state
(init (toupper)))
-----------------------------------------------------------------------
+@endverbatim
When this input method is activated, it is in the initial condition of
-the first state (in this case, it is "init"). In initial conditions,
-no key is being processed and no action is suspended. When it
-receives a key event <a>, it searches branches of the current state
-for a rule that matches with <a> and finds one in the map "toupper".
-Then it executes MAP-ACTIONs (in this case, just inserting "A" in the
-preedit buffer). After all MAP-ACTIONSs are executed, the input
-method shift to the initial condition of the current state.
+the first state (in this case, the only state <tt>init</tt>). In the
+initial condition, no key is being processed and no action is
+suspended. When the input method receives a key event \<a\>, it
+searches branches in the current state for a rule that matches \<a\>
+and finds one in the map <tt>toupper</tt>. Then it executes MAP-ACTIONs
+(in this case, just inserting "A" in the preedit buffer). After all
+MAP-ACTIONs have been executed, the input method shifts to the initial
+condition of the current state.
+
+The shift to <em>the initial condition of the first state</em> has a special
+meaning; it commits all characters in the preedit buffer then clears
+the preedit buffer.
-The shifting to "the initial condition of the first state" has a
-special meaning. It commits all characters in the preedit buffer and
-clears it.
+As a result, "A" is given to the application program.
-As a result, "A" is given to an application program.
+When a key event does not match with any rule in the current state,
+that event is unhandled and given back to the application program.
-A German user may want to extend the above example for "ß". As "ß" is
-an uppercase of "ss", he surely want to type "ss" to input "ß". So, he
-will add this rule in "toupper".
+Turkish users may want to extend the above example for "İ" (U+0130:
+LATIN CAPITAL LETTER I WITH DOT ABOVE). It seems that assigning the
+key sequence \<i\> \<i\> for that character is convenient. So, he
+will add this rule in <tt>toupper</tt>.
- ("ss" "ß")
+@verbatim
+ ("ii" "İ")
+@endverbatim
-But we already have this rule too:
+However, we already have the following rule:
- ("s" "S")
+@verbatim
+ ("i" "I")
+@endverbatim
-What happens when a key event <s> is sent to the input method?
+What will happen when a key event \<i\> is sent to the input method?
-No problem. When the input method receives <s>, it inserts "S" in the
-preedit buffer. But, as it detects that there is another rule that may
-match with the additional key event <s>. So, after inserting "S", it
+No problem. When the input method receives \<i\>, it inserts "I" in the
+preedit buffer. It knows that there is another rule that may
+match the additional key event \<i\>. So, after inserting "I", it
suspends the normal behavior of shifting to the initial condition, and
-waits for another key. Thus, a user may see "S" with underline that
+waits for another key. Thus, the user sees "I" with underline, which
indicates it is not yet committed.
-When the input method receives the next <s>, it cancels the effects
-done by the rule for "s" (in this case, the preedit buffer is
-cleared), and executes MAP-ACTIONs of the rule for "ss". So, "ß" is
-inserted in the preedit buffer. This time, as there is no other rules
-that matches with an addition key, it shifts to the initial condition
-of the current state, and commit "ß".
+When the input method receives the next \<i\>, it cancels the effects
+done by the rule for the previous "i" (in this case, the preedit buffer is
+cleared), and executes MAP-ACTIONs of the rule for "ii". So, "İ" is
+inserted in the preedit buffer. This time, as there are no other rules
+that match with an additional key, it shifts to the initial condition
+of the current state, which leads to commit "İ".
-Then, what happens when the next key event is <a> instead of <s>?
+Then, what will happen when the next key event is \<a\> instead of \<i\>?
-No problem too.
+No problem, either.
-The input method knows that there is no rule matching <s> <a> key
-sequence. So, when it receives the next <a>, it executes the
-suspended behavior (i.e. shifting to the initial condition) which
-leads to committing of "S", then try to handle <a> in the current
-state which leads to committing of "A".
+The input method knows that there are no rules that match the \<i\> \<a\> key
+sequence. So, when it receives the next \<a\>, it executes the
+suspended behavior (i.e. shifting to the initial condition), which
+leads to commit "I". Then the input method tries to handle \<a\> in
+the current state, which leads to commit "A".
-So far, we have explained about MAP-ACTION but not about
-BRANCH-ACTION. The format of BRANCH-ACTION is the same as MAP-ACTION.
-It is executed only after a matching rule is determined and the
-corresponding MAP-ACTIONs are executed. A typical use of
+So far, we have explained MAP-ACTION, but not
+BRANCH-ACTION. The format of BRANCH-ACTION is the same as that of MAP-ACTION.
+It is executed only after a matching rule has been determined and the
+corresponding MAP-ACTIONs have been executed. A typical use of
BRANCH-ACTION is to shift to a different state.
-To see this effect, let us modify the current input method to upcase a
-letter only at a beginning of a word (i.e. "capitalizing"). For that purpose,
-we modify the "init" state as this:
+To see this effect, let us modify the current input method to upcase only
+word-initial letters (i.e. to capitalize). For that purpose,
+we modify the "init" state as this:
+@verbatim
(init
(toupper (shift non-upcase)))
+@endverbatim
-Here "(shift non-upcase)" is an action to shift to the state
-"non-upcase" which has two branches as below:
+Here <tt>(shift non-upcase)</tt> is an action to shift to the new state
+<tt>non-upcase</tt>, which has two branches as below:
+@verbatim
(non-upcase
(lower)
(nil (shift init)))
+@endverbatim
-The first branch is simple. We can define the map "lower" as this to
-insert lower letters as is.
+The first branch is simple. We can define the new map <tt>lower</tt> as the
+following to insert lowercase letters as they are.
+@verbatim
(map
...
- (lower ("a" "a") ("b" "b") ... ("z" "z")))
-
-The second branch has a special meaning. The map name "nil" means
-that it matches with any key event that does not match any rules of the
-other maps in the same state. In addition, it does not eat (or
-consume) the key event. We will show the full code of the new input
+ (lower ("a" "a") ("b" "b") ("c" "c") ("d" "d") ("e" "e")
+ ("f" "f") ("g" "g") ("h" "h") ("i" "i") ("j" "j")
+ ("k" "k") ("l" "l") ("m" "m") ("n" "n") ("o" "o")
+ ("p" "p") ("q" "q") ("r" "r") ("s" "s") ("t" "t")
+ ("u" "u") ("v" "v") ("w" "w") ("x" "x") ("y" "y")
+ ("z" "z")))
+@endverbatim
+
+The second branch has a special meaning. The map name <tt>nil</tt> means
+that it matches with any key event that does not match any rules in the
+other maps in the current state. In addition, it does not
+consume any key event. We will show the full code of the new input
method before explaining how it works.
----titlecase.mim------------------------------------------------------
+@verbatim
(input-method en titlecase)
(description (_ "Titlecase letters"))
(title "abc->Abc")
(map
- (toupper ("a" "A") ("b" "B") ... ("z" "Z") ("ss" "ß"))
- (lower ("a" "a") ("b" "b") ... ("z" "z")))
+ (toupper ("a" "A") ("b" "B") ("c" "C") ("d" "D") ("e" "E")
+ ("f" "F") ("g" "G") ("h" "H") ("i" "I") ("j" "J")
+ ("k" "K") ("l" "L") ("m" "M") ("n" "N") ("o" "O")
+ ("p" "P") ("q" "Q") ("r" "R") ("s" "S") ("t" "T")
+ ("u" "U") ("v" "V") ("w" "W") ("x" "X") ("y" "Y")
+ ("z" "Z") ("ii" "İ"))
+ (lower ("a" "a") ("b" "b") ("c" "c") ("d" "d") ("e" "e")
+ ("f" "f") ("g" "g") ("h" "h") ("i" "i") ("j" "j")
+ ("k" "k") ("l" "l") ("m" "m") ("n" "n") ("o" "o")
+ ("p" "p") ("q" "q") ("r" "r") ("s" "s") ("t" "t")
+ ("u" "u") ("v" "v") ("w" "w") ("x" "x") ("y" "y")
+ ("z" "z")))
(state
(init
(toupper (shift non-upcase)))
(non-upcase
(lower (commit))
(nil (shift init))))
-----------------------------------------------------------------------
-
-Let us see what happens when a user types keys <a> <b> < >.
-
-Upon <a>, "A" is committed and the state is changed to "non-upcase".
-So, the next <b> is handled in "non-upcase" state. As it matches with a
-rule in the map "lower", "b" is inserted in the preedit buffer and it
-is committed by the explicit "commit" command of BRANCH-ACTION. After
-that the input method is still in "non-upcase" state. So the next < >
-is also handled in "non-upcase". This time, as no rule in this state
-matches with it, the branch "(nil (shift init))" is selected, and the
-state is changed to init. Please note that < > is not yet handled.
-So, the input method tries to handle it in "init" state. Again no
-rule matches with it. So that event is given back to an application
-program which usually inserts a space for that.
-
-So, when you type "a quick blown fox" with this input method, you get
-"A Quick Blown Fox". OK, you find a typo in "blown", it should be
-"brown". To correct it, perhaps you move a cursor after "l" and type
-Backspace and <r>. But, if you forget to turn off the current input
-method, "R" is inserted. It is not a sophisticated behavior.
-
-To make the input method work well also in such a case, we must use a
+@endverbatim
+
+Let's see what happens when the user types the key sequence \<a\> \<b\> \< \>.
+Upon \<a\>, "A" is inserted into the buffer and the state shifts to <tt>non-upcase</tt>.
+So, the next \<b\> is handled in the <tt>non-upcase</tt> state.
+As it matches a
+rule in the map <tt>lower</tt>, "b" is inserted in the preedit buffer and characters in the
+buffer ("Ab")
+are committed explicitly by the "commit" command in BRANCH-ACTION. After
+that, the input method is still in the <tt>non-upcase</tt> state. So the next \< \>
+is also handled in <tt>non-upcase</tt>. For this time, no rule in this state
+matches it. Thus the branch <tt>(nil (shift init))</tt> is selected and the
+state is shifted to <tt>init</tt>. Please note that \< \> is not yet
+handled because the map <tt>nil</tt> does not consume any key event.
+So, the input method tries to handle it in the <tt>init</tt> state. Again no
+rule matches it. Therefore, that event is given back to the application
+program, which usually inserts a space for that.
+
+When you type "a quick blown fox" with this input method, you get "A
+Quick Blown Fox". OK, you find a typo in "blown", which should be
+"brown". To correct it, you probably move the cursor after "l" and type
+\<Backspace\> and \<r\>. However, if the current input method is still
+active, a capital "R" is inserted. It is not a sophisticated
+behavior.
+
+@section im-surrounding-text Example of utilizing surrounding text support
+
+To make the input method work well also in such a case, we must use
"surrounding text support". It is a way to check characters around
-the inputting spot and delete them if necessary. Please note that
-this facility is provided only with Gtk+ applications and Qt
-applications. You cannot use it with such an application that uses XIM
+the inputting spot and delete them if necessary. Note that
+this facility is available only with Gtk+ applications and Qt
+applications. You cannot use it with applications that use XIM
to communicate with an input method.
Before explaining how to utilize "surrounding text support", you must
-understand how to use variables, arithmetic comparison, and
-a conditional action.
+understand how to use variables, arithmetic comparisons, and
+conditional actions.
At first, any symbol (except for several preserved ones) used as ARG
-of an action is treated as a variable. For instance,
+of an action is treated as a variable. For instance, the commands
+@verbatim
(set X 32) (insert X)
+@endverbatim
-sets the variable "X" to integer value 32, and insert a character
+set the variable <tt>X</tt> to integer value 32, then insert a character
whose Unicode character code is 32 (i.e. SPACE).
-The second argument of "set" action can be an expression of this form:
+The second argument of the <tt>set</tt> action can be an expression of this form:
+
+@verbatim
+ (OPERATOR ARG1 [ARG2])
+@endverbatim
- (OPERAND ARG1 [ARG2])
+Both ARG1 and ARG2 can be an expression. So,
-And both ARG1 and ARG2 can be an expression. So,
+@verbatim
+ (set X (+ (* Y 32) Z))
+@endverbatim
- (set X (+ (* Y 32) Z)) --- set "X" to the value of "Y*32+Z"
+sets <tt>X</tt> to the value of <tt>Y * 32 + Z</tt>.
-We have these arithmetic/bitwise OPERANDs (require two arguments):
+We have the following arithmetic/bitwise OPERATORs (require two arguments):
+@verbatim
+ - * / & |
+@endverbatim
-these relational OPERANDs (require two arguments):
+these relational OPERATORs (require two arguments):
+@verbatim
== <= >= < >
+@endverbatim
-and this logical OPERAND (require one argument):
+and this logical OPERATOR (requires one argument):
+@verbatim
!
+@endverbatim
For surrounding text support, we have these preserved variables:
- @-0, @-N, @+N (N is a natural number)
+@verbatim
+ @-0, @-N, @+N (N is a positive integer)
+@endverbatim
The values of them are predefined as below and can not be altered.
- @-0 -- -1 if surrounding text is supported, -2 if not.
- @-N -- N previous character of the preedit buffer. If there is only
- M previous characters in it, the value is (N-M) previous
- character of the inputting spot.
- @+N -- N following character of the preedit buffer. If there is only
- M following characters in it, the value is (N-M) following
- character of the inputting spot.
+<ul>
+<li> <tt>@-0</tt>
+
+-1 if surrounding text is supported, -2 if not.
+
+<li> <tt>@-N</tt>
+
+The Nth previous character in the preedit buffer. If there are only M
+(M<N) previous characters in it, the value is the (N-M)th previous
+character from the inputting spot.
-So, provided that you have this context ("def" is in the preedit
-buffer, 2 "|"s just indicate borders between the preedit buffer and
-the surrounding text):
+<li> <tt>@+N</tt>
+The Nth following character in the preedit buffer. If there are only M
+(M<N) following characters in it, the value is the (N-M)th following
+character from the inputting spot.
+
+</ul>
+
+So, provided that you have this context:
+
+@verbatim
ABC|def|GHI
+@endverbatim
-and your current position in the preedit buffer is just after "d", we
-have these values:
+("def" is in the preedit buffer, two "|"s indicate borders between the
+preedit buffer and the surrounding text) and your current position in
+the preedit buffer is between "d" and "e", you get these values:
+@verbatim
@-3 -- ?B
@-2 -- ?C
@-1 -- ?d
@+1 -- ?e
@+2 -- ?f
@+3 -- ?G
+@endverbatim
-Next, you have to understand a conditional action of this form:
+Next, you have to understand the conditional action of this form:
+@verbatim
(cond
- (EXPR1 ACTION ...)
- (EXPR2 ACTION ...)
+ (EXPR1 ACTION ACTION ...)
+ (EXPR2 ACTION ACTION ...)
...)
+@endverbatim
-where EXPRn are expression. When an input method executes this
-action, it resolves values of EXPRn one by one from the first branch.
-If the value of EXPRm is resolved into nonzero, the corresponding
+where EXPRn are expressions. When an input method executes this
+action, it resolves the values of EXPRn one by one from the first branch.
+If the value of EXPRn is resolved into nonzero, the corresponding
actions are executed.
-Now you are ready to write a new version of input method.
+Now you are ready to write a new version of the input method "Titlecase".
----titlecase2.mim------------------------------------------------------
-(input-method en titlecase)
+@verbatim
+(input-method en titlecase2)
(description (_ "Titlecase letters"))
(title "abc->Abc")
(map
("k" "K") ("l" "L") ("m" "M") ("n" "N") ("o" "O")
("p" "P") ("q" "Q") ("r" "R") ("s" "S") ("t" "T")
("u" "U") ("v" "V") ("w" "W") ("x" "X") ("y" "Y")
- ("z" "Z") ("ss" "ß")))
+ ("z" "Z") ("ii" "İ")))
(state
(init
(toupper
- ;; Now we have one character in the preedit buffer. So, "@-2" is
- ;; the character just before the inputting spot.
+ ;; Now we have exactly one uppercase character in the preedit
+ ;; buffer. So, "@-2" is the character just before the inputting
+ ;; spot.
- (cond ((| (& (>= @-2 ?A) (<= @-2 ?Z)) (& (>= @-2 ?a) (<= @-2 ?z)))
+ (cond ((| (& (>= @-2 ?A) (<= @-2 ?Z))
+ (& (>= @-2 ?a) (<= @-2 ?z))
+ (= @-2 ?İ))
- ;; If that character is A..Z or a..z, remember the
- ;; character in the preedit in X and delete it.
+ ;; If the character before the inputting spot is A..Z,
+ ;; a..z, or İ, remember the only character in the preedit
+ ;; buffer in the variable X and delete it.
(set X @-1) (delete @-)
- ;; Then insert a proper lower case version of X.
+ ;; Then insert the lowercase version of X.
- (cond ((= X ?ß) "ss")
+ (cond ((= X ?İ) "i")
(1 (set X (+ X 32)) (insert X))))))))
-----------------------------------------------------------------------
-
-Above example contains a new action "delete". So, it is time to
-explain more about the preedit buffer. The preedit buffer is a
-temporary place to store a sequence of character. In the buffer, an
-input method keep one position called "current position". The current
-position exist between characters, at the head of the buffer, or at
-the tail of the buffer. The "insert" action inserts characters before
-the current position. For instance, when your preedit
-buffer contains "ab.c" ("." indicates the current position),
-
+@endverbatim
+
+The above example contains the new action <tt>delete</tt>. So, it is time
+to explain more about the preedit buffer. The preedit buffer is a
+temporary place to store a sequence of characters. In this buffer,
+the input method keeps a position called the "current position". The
+current position exists between two characters, at the beginning of
+the buffer, or at the end of the buffer. The <tt>insert</tt> action inserts
+characters before the current position. For instance, when your
+preedit buffer contains "ab.c" ("." indicates the current position),
+
+@verbatim
(insert "xyz")
+@endverbatim
changes the buffer to "abxyz.c".
-There are several predefined variables that hold a position in the
+There are several predefined variables that represent a specific position in the
preedit buffer. They are:
- @<, @=, @> -- the first, current, and last positions
- @-, @+ -- the previous and the next positions
+<ul>
+<li> <tt>@@<, @@=, @@></tt>
-The format of "delete" action is this:
+The first, current, and last positions.
- (delete POS)
-
-and the meaning is to delete characters between the position POS and
-the current position. So, "(delete @-)" deletes one character before
-the current position. The other examples of "delete" actions are:
+<li> <tt>@@-, @@+</tt>
- (delete @+) -- delete the next character
- (delete 0<) -- delete all preceding characters in the buffer
- (delete @>) -- delete all following characters in the buffer
+The previous and the next positions.
+</ul>
-You can change the current position by "move" action as below:
+The format of the <tt>delete</tt> action is this:
- (move @-) -- move the current position to the position before the
- previous character
- (move @<) -- move to the first position
+@verbatim
+ (delete POS)
+@endverbatim
+
+where POS is a predefined positional variable.
+The above action deletes the characters between POS and
+the current position. So, <tt>(delete @-)</tt> deletes one character before
+the current position. The other examples of <tt>delete</tt> include the followings:
+
+@verbatim
+ (delete @+) ; delete the next character
+ (delete @<) ; delete all the preceding characters in the buffer
+ (delete @>) ; delete all the following characters in the buffer
+@endverbatim
+
+You can change the current position using the <tt>move</tt> action as below:
+
+@verbatim
+ (move @-) ; move the current position to the position before the
+ previous character
+ (move @<) ; move to the first position
+@endverbatim
+
+Other positional variables work similarly.
+
+Let's see how our new example works. Whatever a key event is, the
+input method is in its only state, <tt>init</tt>. Since an event of a lower letter
+key is firstly handled by MAP-ACTIONs, every key is changed into the
+corresponding uppercase and put into the preedit buffer. Now this character
+can be accessed with <tt>@-1</tt>.
+
+How can we tell whether the new character should be a lowercase or an
+uppercase? We can do so by checking the character before it, i.e.
+<tt>@-2</tt>. BRANCH-ACTIONs in the <tt>init</tt> state do the job.
+
+It first checks if the character <tt>@-2</tt> is between A to Z, between
+a to z, or İ by the conditional below.
+
+@verbatim
+ (cond ((| (& (>= @-2 ?A) (<= @-2 ?Z))
+ (& (>= @-2 ?a) (<= @-2 ?z))
+ (= @-2 ?İ))
+@endverbatim
+
+If not, there is nothing to do specially. If so, our new key should
+be changed back into lowercase. Since the uppercase character is
+already in the preedit buffer, we retrieve and remember it in the
+variable <tt>X</tt> by
+
+@verbatim
+ (set X @-1)
+@endverbatim
+and then delete that character by
-Let us see how our new example works. Whatever a key event is, the
-input method is in its only state, "init". An event is first handled
-by MAP-ACTIONs, so that every key is shifted to upcase and put into
-the preedit area. The character now put into the preedit buffer and
-can be retrieved by @-1.
+@verbatim
+ (delete @-)
+@endverbatim
-How can we determine if the new character should be in its lower case?
-We have to check the character before it, that is, @-2.
-BRANCH-ACTIONs in the "init" state do the job.
+Lastly we re-insert the character in its lowercase form. The
+problem here is that "İ" must be changed into "i", so we need another
+conditional. The first branch
-It first checks if the character @-2 is between A to Z, or between a
-to z, by the conditional below.
+@verbatim
+ ((= X ?İ) "i")
+@endverbatim
- (cond ((| (& (>= @-2 ?A) (<= @-2 ?Z)) (& (>= @-2 ?a) (<= @-2 ?z)))
+means that "if the character remembered in X is 'İ', 'i' is inserted".
-If not, the work with this key event is done. If so, our new key
-should be changed back to lowercase. The upcase character is already
-in the preedit buffer and we have to retrieve and remember it in the
-variable X by
+The second branch
- (set X @-1)
+@verbatim
+ (1 (set X (+ X 32)) (insert X))
+@endverbatim
-and then delete the character by
+starts with "1", which is always resolved into nonzero, so this branch
+is a catchall. Actions in this branch increase <tt>X</tt> by 32, then
+insert <tt>X</tt>. In other words, they change A...Z into a...z
+respectively and insert the resulting lowercase character into the
+preedit buffer. As the input method reaches the end of the
+BRANCH-ACTIONs, the character is committed.
- (delete @-)
+This new input method always checks the character before the current
+position, so "A Quick Blown Fox" will be successfully fixed to "A
+Quick Brown Fox" by the key sequence \<BackSpace\> \<r\>.
-Lastly we insert back the character in its lowercase form. The
-problem here is that ß must be changed to "ss", so we need another
-conditional. The first branch means that "if the character remembered
-in X is ß, "ss" is inserted".
-The second branch
+*/
- (1 (set X (+ X 32)) (insert X))
+/*
+Copyright (C) 2007
+ National Institute of Advanced Industrial Science and Technology (AIST)
+ Registration Number H15PRO112
-starts with "1" that is always resolved into nonzero, so this branch
-is catchall. Actions in this branch shifts up X by 32 and then insert
-it, that is, they make A...Z into a...z respectively and inserts the
-lower case character to the preedit buffer. As the input method
-reached the end of the BRANCH-ACTIONs, the character is commited.
+This file is part of the m17n database; a sub-part of the m17n
+library.
-This new input method always checks the character before the current
-position, so "A Quick Blown Fox" will be successfully fixed to "A
-Quick Brown Fox" by a backspace and <r>.
+The m17n library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public License
+as published by the Free Software Foundation; either version 2.1 of
+the License, or (at your option) any later version.
+The m17n library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+You should have received a copy of the GNU Lesser General Public
+License along with the m17n library; if not, write to the Free
+Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.
+*/
projects / m17n / m17n-db.git / blobdiff