[SourceForge.net <noreply@so...>]

Feature Requests item #1512018, was opened at 2006-06-25 14:57
Message generated for change (Tracker Item Submitted) made by Item Submitter
You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=381350&aid=1512018&group_id=24366

Please note that this message will contain a full copy of the comment thread,
including the initial issue submission, for this request,
not just the latest update.
Category: keyboard
Group: None
Status: Open
Priority: 5
Submitted By: Manabu Fujiwara (fujiwara_manabu)
Assigned to: Peter Åstrand (astrand)
Summary: Japanese text input support on Solaris

Initial Comment:
In the Japanese text input environment, Caps Lock key 
and Katakana key have indispensable function.
Additionally, In the Solaris Japanese text input 
environment, Mode_switch key is assigned as Katakana 
key.
And both Caps Lock and Mode_switch key are pseudo-
lock key then differ from remote Windows environment 
key event behavior.
Not only that, Even in same Solaris environment, 
These keys have different behavior between Xsun and 
Xorg.
These behavior ruins remote Windows Japanese text 
input environment of Solaris rdesktop RDP client.

It's possible to fix Windows Japanese text input 
environment behavior of Solaris rdesktop by change 
Solaris OS X keymap.
But that solution restrict functionality of, and 
change behavior on Solaris-side Japanese text input 
environment.

To fix these issues without change X keymaps of 
Solaris OS, I'd like to suggest following changes.

regards,


diff from xkeymap.c 1.92

681a682,835
> /* Handle pseudo lock keys
> Certain Xserver handle pseudo lock key motion to 
the event like this:
> (pattern A)
> key motion        press  ->  release  ->  press   -
>  release
> key event         Pressed+Released        
Pressed+Released
> While other does:
> (pattern B)
> key motion        press  ->  release  ->  press   -
>  release
> key event       Pressed                 Released
> Therefore, We must handle this Key Released event 
as Key Pressed,
> while ignoring Released event of Pressed+Released 
combination events.
> In addition, In certain Xserver, if shift is 
pressed, pattern A becomes:
> (pattern C)
> key motion        press  ->  release  ->  press   -
>  release
> key event         Pressed    Released     
Pressed     Released
> Following functions distiguish these patterns and 
determine
> if Key Released event is treated as Pressed.
> */
> BOOL
> is_ensure_duration_time( long sec, long usec )
> {
>       struct timeval st;
>       static long prev_tv_sec = 0;
>       static long prev_tv_usec = 0;
>       long long llt;
>       long long prevllt;
>       long long durationllt;
>
>       gettimeofday(&st,0);
>       llt = (long long)1000000 * (long long)
st.tv_sec + (long long)st.tv_usec;
>       prevllt = (long long)1000000 * (long long)
prev_tv_sec + (long long)prev_tv_usec;
>       durationllt = (long long)1000000 * (long long)
sec + (long long)usec;
>       prev_tv_sec = st.tv_sec;
>       prev_tv_usec = st.tv_usec;
>       if( llt - prevllt > durationllt ){
>               return True;
>       }else return False;
> }
>
> BOOL
> handle_pseudo_lock_keys(uint32 keysym, unsigned int 
state, uint32 ev_time, BOOL pressed)
> {
>       static BOOL first_capslock = 1;
>       static BOOL shift_used = 0;
>       static BOOL first_caps_release = 1;
>       static BOOL first_caps_press = 1;
>       static BOOL prev_caps_state_1 = 0;
>       static BOOL prev_caps_state_2 = 0;
>       static BOOL prev_caps_state_3 = 0;
>       BOOL current_caps_state;
>       BOOL current_shift_state;
>       key_translation tr = { 0, 0, 0, 0 };
>       key_translation *ptr;
>
>       switch (keysym)
>       {
>               /* Not a pseudo lock keys, but used 
to distiguish shift+CapsLock patterns. */
>               case XK_Shift_L:
>               case XK_Shift_R:
>
>                       shift_used = 1;
>                       break;
>
>               case XK_Caps_Lock:
>
>                       current_caps_state = 
get_key_state(state, XK_Caps_Lock);
>                       current_shift_state = 
get_key_state(state, XK_Shift_L) ||  get_key_state
(state, XK_Shift_L);
>
>                       if( first_capslock ){
>                               first_capslock = 0;
>                               if( 
current_caps_state ){
>                                       
prev_caps_state_1 = 0;
>                                       
prev_caps_state_2 = 1;
>                                       
prev_caps_state_3 = 0;
>                               }else{
>                                       
prev_caps_state_1 = 1;
>                                       
prev_caps_state_2 = 0;
>                                       
prev_caps_state_3 = 1;
>                               }
>                       }
>                       DEBUG_KBD(( "CapsLock state = 
%d ", prev_caps_state_1));
>                       DEBUG_KBD(( "%d ", 
prev_caps_state_2));
>                       DEBUG_KBD(( "%d ", 
prev_caps_state_3));
>                       DEBUG_KBD(( "%d ", 
current_caps_state));
>                       DEBUG_KBD(( "shift used(%d)
\n", shift_used));
>
>                       if( pressed ){
>                               if( first_caps_press )
{
>                                       
first_caps_press = 0;
>                                       shift_used = 
0;
>                                       
is_ensure_duration_time(0,0);
>                               }
>                       }else{
>                               if(prev_caps_state_1 
== 0
>                                  && 
prev_caps_state_2 == 1
>                                  && 
prev_caps_state_3 == 0
>                                  && 
current_caps_state == 1){
>                                       if( 
first_caps_release ){
>                                               
first_caps_release = 0;
>                                               if( 
current_shift_state && shift_used ){
>                                                     
  pressed = 1;
>                                                     
  DEBUG_KBD(("1st Treate Caps_Lock KeyRelease event 
as KeyPress by shift key usage.\n"));
>                                               }else 
if( is_ensure_duration_time(0,100000) ){
>                                                     
  pressed = 1;
>                                                     
  DEBUG_KBD(("1st Treate Caps_Lock KeyRelease event 
as KeyPress by duration time.\n"));
>                                               }
>                                       }
>                                       else{
>                                               
pressed = 1;
>                                               
DEBUG_KBD(("Treate Caps_Lock KeyRelease event as 
KeyPress by lock state pattern.\n"));
>                                       }
>                               }
>                       }
>                       prev_caps_state_1 = 
prev_caps_state_2;
>                       prev_caps_state_2 = 
prev_caps_state_3;
>                       prev_caps_state_3 = 
current_caps_state;
>
>                       if(pressed){
>
>                               ptr = keymap[keysym & 
KEYMAP_MASK];
>                               if(ptr){
>                                       tr = *ptr;
>                                       
rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
>                                       
rdp_send_scancode(ev_time, RDP_KEYRELEASE, 
tr.scancode);
>                               }
>                       }
>                       return True;
>                       break;
>
>               case XK_Mode_switch:
>
>                       if( !pressed ){
>                               if( 
is_ensure_duration_time(0,100000) ){
>                                       pressed = 1;
>                                       DEBUG_KBD
(("Treate Mode_Switch KeyRelease event as KeyPress by 
duration time.\n"));
>                               }
>                       }else{
>                               
is_ensure_duration_time(0,0);
>                       }
>
>                       if(pressed){
>                       ptr = keymap[keysym & 
KEYMAP_MASK];
>                               if(ptr){
>                                       tr = *ptr;
>                                       
rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
>                                       
rdp_send_scancode(ev_time, RDP_KEYRELEASE, 
tr.scancode);
>                               }
>                       }
>                       return True;
>                       break;
>       }
>       return False;
> }
>
694a849,851
>               if (handle_pseudo_lock_keys(keysym, 
state, ev_time, pressed))
>                       return;
>
696a854,858
>                       /* Handle Caps_Lock and 
Mode_switch Key state */
>                       if( get_key_state(state, 
XK_Caps_Lock) || get_key_state(state, 
XK_Mode_switch) ) {
>                               rdp_send_scancode
(ev_time, RDP_KEYPRESS, tr.scancode);
>                               return;
>                       }


diff from keymaps/ja 1.8

8c8
< kana_NU 0x02 altgr
---
> kana_NU 0x02 localstate
10c10
< kana_FU 0x03 altgr
---
> kana_FU 0x03 localstate
12,13c12,13
< kana_A 0x04 altgr
< kana_a 0x04 shift altgr
---
> kana_A 0x04 localstate
> kana_a 0x04 localstate
15,16c15,16
< kana_U 0x05 altgr
< kana_u 0x05 shift altgr
---
> kana_U 0x05 localstate
> kana_u 0x05 localstate
18,19c18,19
< kana_E 0x06 altgr
< kana_e 0x06 shift altgr
---
> kana_E 0x06 localstate
> kana_e 0x06 localstate
21,22c21,22
< kana_O 0x07 altgr
< kana_o 0x07 shift altgr
---
> kana_O 0x07 localstate
> kana_o 0x07 localstate
24,25c24,25
< kana_YA 0x08 altgr
< kana_ya 0x08 shift altgr
---
> kana_YA 0x08 localstate
> kana_ya 0x08 localstate
27,28c27,28
< kana_YU 0x09 altgr
< kana_yu 0x09 shift altgr
---
> kana_YU 0x09 localstate
> kana_yu 0x09 localstate
30,31c30,31
< kana_YO 0x0a altgr
< kana_yo 0x0a shift altgr
---
> kana_YO 0x0a localstate
> kana_yo 0x0a localstate
33,34c33,34
< kana_WA 0x0b altgr
< kana_WO 0x0b shift altgr
---
> kana_WA 0x0b localstate
> kana_WO 0x0b localstate
37c37
< kana_HO 0x0c altgr
---
> kana_HO 0x0c localstate
40,51c40,51
< kana_HE 0x0d altgr
< kana_TA 0x10 altgr
< kana_TE 0x11 altgr
< kana_I 0x12 altgr
< kana_i 0x12 shift altgr
< kana_SU 0x13 altgr
< kana_KA 0x14 altgr
< kana_N 0x15 altgr
< kana_NA 0x16 altgr
< kana_NI 0x17 altgr
< kana_RA 0x18 altgr
< kana_SE 0x19 altgr
---
> kana_HE 0x0d localstate
> kana_TA 0x10 localstate
> kana_TE 0x11 localstate
> kana_I 0x12 localstate
> kana_i 0x12 localstate
> kana_SU 0x13 localstate
> kana_KA 0x14 localstate
> kana_N 0x15 localstate
> kana_NA 0x16 localstate
> kana_NI 0x17 localstate
> kana_RA 0x18 localstate
> kana_SE 0x19 localstate
58,67c58,67
< kana_openingbracket 0x1b shift altgr
< kana_CHI 0x1e altgr
< kana_TO 0x1f altgr
< kana_SHI 0x20 altgr
< kana_HA 0x21 altgr
< kana_KI 0x22 altgr
< kana_KU 0x23 altgr
< kana_MA 0x24 altgr
< kana_NO 0x25 altgr
< kana_RI 0x26 altgr
---
> kana_openingbracket 0x1b localstate
> kana_CHI 0x1e localstate
> kana_TO 0x1f localstate
> kana_SHI 0x20 localstate
> kana_HA 0x21 localstate
> kana_KI 0x22 localstate
> kana_KU 0x23 localstate
> kana_MA 0x24 localstate
> kana_NO 0x25 localstate
> kana_RI 0x26 localstate
70c70
< kana_RE 0x27 altgr
---
> kana_RE 0x27 localstate
73c73
< kana_KE 0x28 altgr
---
> kana_KE 0x28 localstate
77,86c77,86
< kana_MU 0x2b altgr
< kana_closingbracket 0x2b shift altgr
< kana_TSU 0x2c altgr
< kana_tsu 0x2c shift altgr
< kana_SA 0x2d altgr
< kana_SO 0x2e altgr
< kana_HI 0x2f altgr
< kana_KO 0x30 altgr
< kana_MI 0x31 altgr
< kana_MO 0x32 altgr
---
> kana_MU 0x2b localstate
> kana_closingbracket 0x2b localstate
> kana_TSU 0x2c localstate
> kana_tsu 0x2c localstate
> kana_SA 0x2d localstate
> kana_SO 0x2e localstate
> kana_HI 0x2f localstate
> kana_KO 0x30 localstate
> kana_MI 0x31 localstate
> kana_MO 0x32 localstate
89,90c89,90
< kana_NE 0x33 altgr
< kana_comma 0x33 shift altgr
---
> kana_NE 0x33 localstate
> kana_comma 0x33 localstate
93,94c93,94
< kana_RU 0x34 altgr
< kana_fullstop 0x34 shift altgr
---
> kana_RU 0x34 localstate
> kana_fullstop 0x34 localstate
97,101c97,101
< kana_ME 0x35 altgr
< kana_conjunctive 0x35 shift altgr
< Eisu_toggle 0x3a shift
< Execute 0x54 shift
< Kanji 0x70
---
> kana_ME 0x35 localstate
> kana_conjunctive 0x35 localstate
> Eisu_toggle 0x3a
> Execute 0x7b
> Kanji 0x79
105c105
< Henkan_Mode 0x79
---
> Henkan_Mode 0x29
107a108,144
> Hiragana 0x70 localstate
> Mode_switch 0x70 localstate
> SunSys_Req 0xb7 localstate
> Multi_key 0xdd
> kana_RO 0x73 localstate
> prolongedsound 0x7d altgr
> yen 0x7d
> Caps_Lock 0x3a localstate
> Alt_R 0x38
> Kana_Lock 0x70 localstate
> 0 0x0b localstate
> Q 0x10 localstate
> W 0x11 localstate
> E 0x12 localstate
> R 0x13 localstate
> T 0x14 localstate
> Y 0x15 localstate
> U 0x16 localstate
> I 0x17 localstate
> O 0x18 localstate
> P 0x19 localstate
> A 0x1e localstate
> S 0x1f localstate
> D 0x20 localstate
> F 0x21 localstate
> G 0x22 localstate
> H 0x23 localstate
> J 0x24 localstate
> K 0x25 localstate
> L 0x26 localstate
> Z 0x2c localstate
> X 0x2d localstate
> C 0x2e localstate
> V 0x2f localstate
> B 0x30 localstate
> N 0x31 localstate
> M 0x32 localstate



----------------------------------------------------------------------

You can respond by visiting: 
https://sourceforge.net/tracker/?func=detail&atid=381350&aid=1512018&group_id=24366