874 lines
15 KiB
C
874 lines
15 KiB
C
/*
|
|
* Copyright (c) 1994 Sony Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL SONY CORPORATION BE LIABLE FOR ANY CLAIM,
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
|
|
* THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name of Sony Corporation
|
|
* shall not be used in advertising or otherwise to promote the sale, use
|
|
* or other dealings in this Software without prior written authorization
|
|
* from Sony Corporation.
|
|
*
|
|
*/
|
|
|
|
#include "common.h"
|
|
#include "key.h"
|
|
#include "rk.h"
|
|
|
|
extern int keyvalue;
|
|
|
|
int rkerrbell = 0;
|
|
static int delkey = -1;
|
|
static int bskey;
|
|
|
|
#define SPAN_FLUSH 0
|
|
#define SPAN_END 1
|
|
|
|
save_span(mode) int mode;
|
|
{
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
switch(mode) {
|
|
case SPAN_FLUSH:
|
|
cv->span_point = 0;
|
|
cv->ha_point = 0;
|
|
cv->out_point = 0;
|
|
save_span_p();
|
|
break;
|
|
case SPAN_END:
|
|
if(cv->out_point < cv->out_epoint) {
|
|
Clear_EOL();
|
|
cv->out_point = cv->out_epoint;
|
|
cv->ha_point = cv->ha_epoint;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
save_span_p() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
cv->span_p[cv->span_point] = &(cv->out_buf[cv->out_point]);
|
|
cv->span_l[cv->span_point] = 0;
|
|
}
|
|
|
|
isspaned() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
if(cv->out_buf[0] != '\0')
|
|
return (1);
|
|
else
|
|
return (0);
|
|
}
|
|
|
|
buffers_clear() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
pointer_clear();
|
|
if(flush_conversion)
|
|
cv->CurBun = -1;
|
|
else
|
|
cv->CurBun = 0;
|
|
}
|
|
|
|
pointer_clear() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
cv->ha_point = cv->ha_epoint = 0;
|
|
*(cv->Halpha) = '\0';
|
|
os_point = 0;
|
|
cv->out_point = cv->out_epoint = 0;
|
|
*(cv->out_buf) = '\0';
|
|
cv->Kanji = 0;
|
|
save_span(SPAN_FLUSH);
|
|
sj3_rkclear();
|
|
}
|
|
|
|
typedef struct _SaveSet {
|
|
wchar16_t out_buf[BUFFLENGTH * 2];
|
|
unsigned short out_mode[BUFFLENGTH * 2];
|
|
unsigned short out_point;
|
|
unsigned short ha_point;
|
|
wchar16_t Halpha[BUFFLENGTH];
|
|
unsigned char in_mode[BUFFLENGTH * 2];
|
|
} SaveSet;
|
|
|
|
static SaveSet save_set0;
|
|
|
|
StoreSaveSet() {
|
|
Conversion* cv;
|
|
SaveSet* sv;
|
|
|
|
cv = GetConversion();
|
|
if(cv->out_point) {
|
|
sv = &save_set0;
|
|
sv->out_point = cv->out_point;
|
|
sv->ha_point = cv->ha_point;
|
|
memcpy(sv->out_mode, cv->out_mode,
|
|
cv->out_point * sizeof(unsigned short));
|
|
memcpy(sv->in_mode, cv->in_mode,
|
|
cv->out_point * sizeof(unsigned char));
|
|
wscpy(sv->Halpha, cv->Halpha);
|
|
wscpy(sv->out_buf, cv->out_buf);
|
|
}
|
|
}
|
|
|
|
RestoreSaveSet() {
|
|
Conversion* cv;
|
|
SaveSet* sv;
|
|
|
|
sv = &save_set0;
|
|
if(sv->out_point) {
|
|
cv = GetConversion();
|
|
cv->out_point = sv->out_point;
|
|
cv->ha_point = sv->ha_point;
|
|
memcpy(cv->out_mode, sv->out_mode,
|
|
sv->out_point * sizeof(unsigned short));
|
|
memcpy(cv->in_mode, sv->in_mode,
|
|
sv->out_point * sizeof(unsigned char));
|
|
wscpy(cv->Halpha, sv->Halpha);
|
|
wscpy(cv->out_buf, sv->out_buf);
|
|
}
|
|
}
|
|
|
|
history_empty() {
|
|
SaveSet* sv;
|
|
|
|
sv = &save_set0;
|
|
if(sv->out_point)
|
|
return (0);
|
|
else
|
|
return (1);
|
|
}
|
|
|
|
History() {
|
|
Conversion* cv;
|
|
SaveSet* sv;
|
|
|
|
sv = &save_set0;
|
|
if(sv->out_point) {
|
|
RestoreSaveSet();
|
|
cv = GetConversion();
|
|
if(flush_conversion)
|
|
cv->CurBun = -1;
|
|
else
|
|
cv->CurBun = 0;
|
|
}
|
|
}
|
|
|
|
ClearBuffer() {
|
|
Clear_EOL();
|
|
Ccheck();
|
|
Cclear(1);
|
|
all_set_up();
|
|
}
|
|
|
|
SetCflag() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
cv->Cflag = 1;
|
|
}
|
|
|
|
ClearCflag() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
cv->Cflag = 0;
|
|
}
|
|
|
|
IsCflag() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
return (cv->Cflag);
|
|
}
|
|
|
|
exec_kettei() {
|
|
Conversion* cv;
|
|
int len;
|
|
wchar16_t kanji[BUFFLENGTH * 2];
|
|
|
|
cv = GetConversion();
|
|
save_span(SPAN_END);
|
|
if(cv->Kanji != 0) {
|
|
len = Bkanji(kanji);
|
|
Ccheck();
|
|
Cclear(1);
|
|
master_write(kanji, len);
|
|
if(cv->word_regist) {
|
|
cv->word_regist = 0;
|
|
} else {
|
|
if(is_bstudy()) {
|
|
cl_gakushuu();
|
|
}
|
|
}
|
|
} else if(isspaned()) {
|
|
if(BuffYes()) {
|
|
Ccheck();
|
|
Cclear(1);
|
|
}
|
|
if(!BuffYes())
|
|
vbackchar(cv->out_point);
|
|
if(cv->out_point)
|
|
master_write(cv->out_buf, cv->out_point);
|
|
|
|
if(BuffYes())
|
|
master_flush();
|
|
StoreSaveSet();
|
|
}
|
|
buffers_clear();
|
|
ResetHenkan();
|
|
SetCflag();
|
|
}
|
|
|
|
set_rkebell(word) struct wordent word[];
|
|
{
|
|
if(match(word[1].word_str, WCOn))
|
|
rkerrbell = 1;
|
|
if(match(word[1].word_str, WCOff))
|
|
rkerrbell = 0;
|
|
}
|
|
|
|
ChangeBuffMode() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
if(cv->BuffMode == BUFF) {
|
|
sj3_rkebell(0);
|
|
cv->BuffMode = UNBUFF;
|
|
} else {
|
|
sj3_rkebell(rkerrbell);
|
|
cv->BuffMode = BUFF;
|
|
}
|
|
}
|
|
|
|
BuffYes() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
if(cv->BuffMode == BUFF)
|
|
return (1);
|
|
else
|
|
return (0);
|
|
}
|
|
|
|
#define STAT_HENKAN 1
|
|
#define STAT_MUHENKAN 2
|
|
|
|
IsHenkan() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
return (cv->henkanflag);
|
|
}
|
|
|
|
IsMuhenkan() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
return (cv->henkanflag & STAT_MUHENKAN);
|
|
}
|
|
|
|
SetMuhenkan() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
cv->henkanflag |= STAT_MUHENKAN;
|
|
}
|
|
|
|
SetHenkan() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
cv->henkanflag = STAT_HENKAN;
|
|
}
|
|
|
|
ResetHenkan() {
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
cv->henkanflag = 0;
|
|
}
|
|
|
|
all_set_up() {
|
|
buffers_clear();
|
|
SetCflag();
|
|
ResetHenkan();
|
|
}
|
|
|
|
static int convertflag;
|
|
static int small;
|
|
|
|
stat_conv_on() {
|
|
convertflag = 1;
|
|
}
|
|
|
|
stat_init() {
|
|
stat_conv_on();
|
|
all_set_up();
|
|
disp_mode();
|
|
small = 0;
|
|
}
|
|
|
|
get_pseq() {
|
|
return (write_pseq(1));
|
|
}
|
|
|
|
stat_conv() {
|
|
Conversion* cv;
|
|
extern int allways_buff;
|
|
int inc;
|
|
int i;
|
|
unsigned short svlen;
|
|
|
|
cv = GetConversion();
|
|
cv->word_regist = 0;
|
|
while(convertflag) {
|
|
if((inc = inkey()) == EOF)
|
|
break;
|
|
|
|
cv = GetConversion();
|
|
if(allways_buff)
|
|
cv->BuffMode = BUFF;
|
|
more:
|
|
switch(keyvalue) {
|
|
|
|
case KEY_NORMAL:
|
|
small = 0;
|
|
if(inc == EOF)
|
|
break;
|
|
if(IsHenkan()) {
|
|
if(is_bsdel(inc)) {
|
|
Bdelete();
|
|
break;
|
|
} else if(inc < ' ' && inc != '\n' &&
|
|
inc != '\r' && inc != '\t' &&
|
|
!IsESC(inc) && !isintr(inc)) {
|
|
beep();
|
|
break;
|
|
} else {
|
|
exec_kettei();
|
|
}
|
|
}
|
|
|
|
save_obuf();
|
|
svlen = cv->Vlen;
|
|
while(exec_romaji(inc)) {
|
|
if(os_point > 0 && svlen != cv->Vlen) {
|
|
i = svlen - cv->Vlen;
|
|
svlen = cv->Vlen;
|
|
vprintU(osave_buf, 1);
|
|
if(i > 0)
|
|
Clear_EOL();
|
|
Cgoto(svlen);
|
|
}
|
|
inc = inkey();
|
|
if(keyvalue != KEY_NORMAL &&
|
|
(exec_romaji(0) == 0 || keyvalue == KEY_CONV)) {
|
|
restore_obuf();
|
|
goto more;
|
|
}
|
|
}
|
|
restore_obuf();
|
|
if(is_del(inc) && (!IsCflag() && isspaned())) {
|
|
if(cv->out_point < cv->out_epoint) {
|
|
move_cur(KEY_RIGHT);
|
|
inc = bskey;
|
|
goto more;
|
|
}
|
|
} else
|
|
exec_ctrl(inc);
|
|
break;
|
|
case KEY_KETTEI:
|
|
small = 0;
|
|
if(!IsCflag()) {
|
|
exec_kettei();
|
|
} else if(cv->Imode != MODE_HALPHA || BuffYes()) {
|
|
if(cv->Imode != MODE_HALPHA)
|
|
exec_mode(KEY_HALPHA);
|
|
if(BuffYes())
|
|
ChangeBuffMode();
|
|
disp_mode();
|
|
}
|
|
break;
|
|
case KEY_CONV:
|
|
small = 0;
|
|
if(!no_flush)
|
|
exec_kettei();
|
|
convertflag = 0;
|
|
break;
|
|
case KEY_CANCEL:
|
|
small = 0;
|
|
if(!IsCflag())
|
|
ClearBuffer();
|
|
else if((inc = get_pseq()) != 0)
|
|
exec_ctrl(inc);
|
|
break;
|
|
case KEY_RECONV:
|
|
small = 0;
|
|
if(IsCflag()) {
|
|
if(history_empty()) {
|
|
if((inc = get_pseq()) != 0)
|
|
exec_ctrl(inc);
|
|
break;
|
|
} else {
|
|
History();
|
|
Csave();
|
|
ClearCflag();
|
|
}
|
|
} else {
|
|
if(IsHenkan()) {
|
|
History();
|
|
ResetHenkan();
|
|
} else {
|
|
beep();
|
|
break;
|
|
}
|
|
}
|
|
exec_henkan();
|
|
SetHenkan();
|
|
break;
|
|
case KEY_HENKAN:
|
|
small = 0;
|
|
if(!IsCflag()) {
|
|
if(IsMuhenkan()) {
|
|
exec_henkan();
|
|
SetHenkan();
|
|
}
|
|
if(IsHenkan()) {
|
|
exec_douon();
|
|
} else {
|
|
save_span(SPAN_END);
|
|
Ccheck();
|
|
StoreSaveSet();
|
|
exec_henkan();
|
|
SetHenkan();
|
|
}
|
|
} else if((inc = write_pseq(3)) >= ' ' && inc <= '~')
|
|
exec_ctrl(inc);
|
|
else if(cv->Imode != MODE_ZHIRA || !BuffYes()) {
|
|
if(cv->Imode != MODE_ZHIRA) {
|
|
exec_mode(KEY_ZHIRA);
|
|
}
|
|
if(!BuffYes()) {
|
|
ChangeBuffMode();
|
|
}
|
|
disp_mode();
|
|
}
|
|
break;
|
|
case KEY_MUHENKAN:
|
|
small = 0;
|
|
if(flush_conversion && !IsCflag() &&
|
|
cv->CurBun == -1) {
|
|
if(IsHenkan()) {
|
|
exec_muhenkan(0);
|
|
SetHenkan();
|
|
} else {
|
|
save_span(SPAN_END);
|
|
Ccheck();
|
|
exec_muhenkan(1);
|
|
SetHenkan();
|
|
SetMuhenkan();
|
|
}
|
|
break;
|
|
}
|
|
case KEY_TOGGLE:
|
|
case KEY_ZHIRA:
|
|
case KEY_HALPHA:
|
|
case KEY_ZALPHA:
|
|
case KEY_HKATA:
|
|
case KEY_ZKATA:
|
|
case KEY_CODE:
|
|
small = 0;
|
|
if(cv->CurBun == -1)
|
|
exec_kettei();
|
|
else if(IsHenkan()) {
|
|
Bchange(keyvalue);
|
|
break;
|
|
}
|
|
if(keyvalue == KEY_TOGGLE)
|
|
keyvalue = toggle_mode(cv->Imode);
|
|
exec_mode(keyvalue);
|
|
disp_mode();
|
|
break;
|
|
case KEY_WRAP:
|
|
small = 0;
|
|
if(IsHenkan())
|
|
wrap_douon(0);
|
|
else if((inc = get_pseq()) != 0)
|
|
exec_ctrl(inc);
|
|
break;
|
|
case KEY_WRAPBACK:
|
|
small = 0;
|
|
if(IsHenkan())
|
|
wrap_douon(1);
|
|
else if((inc = get_pseq()) != 0)
|
|
exec_ctrl(inc);
|
|
break;
|
|
case KEY_LEFT:
|
|
case KEY_RIGHT:
|
|
case KEY_UP:
|
|
case KEY_DOWN:
|
|
if(IsHenkan()) {
|
|
switch(keyvalue) {
|
|
case KEY_LEFT:
|
|
Bleft();
|
|
small = 0;
|
|
break;
|
|
case KEY_RIGHT:
|
|
Bright();
|
|
small = 0;
|
|
break;
|
|
case KEY_UP:
|
|
small = Bbig();
|
|
break;
|
|
case KEY_DOWN:
|
|
small = Bsmall(small);
|
|
break;
|
|
}
|
|
} else if(cv->Imode == MODE_CODE) {
|
|
small = 0;
|
|
if(BuffYes() && IsCflag()) {
|
|
Csave();
|
|
ClearCflag();
|
|
}
|
|
kigou();
|
|
if(flush_conversion)
|
|
exec_kettei();
|
|
} else if(!IsCflag() && (keyvalue == KEY_LEFT ||
|
|
keyvalue == KEY_RIGHT)) {
|
|
small = 0;
|
|
move_cur(keyvalue);
|
|
} else if(!BuffYes() && cv->Imode == MODE_HALPHA) {
|
|
small = 0;
|
|
write_pseq(0);
|
|
|
|
} else if(IsCflag() && (inc = get_pseq()) != 0) {
|
|
small = 0;
|
|
exec_ctrl(inc);
|
|
}
|
|
break;
|
|
case KEY_TOP:
|
|
case KEY_END:
|
|
if(IsHenkan()) {
|
|
switch(keyvalue) {
|
|
case KEY_TOP:
|
|
Btop();
|
|
small = 0;
|
|
break;
|
|
case KEY_END:
|
|
Blast();
|
|
small = 0;
|
|
break;
|
|
}
|
|
} else if(!IsCflag()) {
|
|
small = 0;
|
|
move_cur(keyvalue);
|
|
} else if((inc = get_pseq()) != 0) {
|
|
small = 0;
|
|
exec_ctrl(inc);
|
|
}
|
|
break;
|
|
case KEY_EDIT:
|
|
case KEY_TOROKU:
|
|
case KEY_SHOUKYO:
|
|
small = 0;
|
|
if(IsCflag() && (inc = get_pseq()) != 0)
|
|
exec_ctrl(inc);
|
|
case KEY_ETC:
|
|
case KEY_HELP:
|
|
case KEY_SJRC:
|
|
case KEY_RECONNECT:
|
|
small = 0;
|
|
i = exec_etc(keyvalue);
|
|
disp_mode();
|
|
if(i != KEY_NORMAL) {
|
|
keyvalue = i;
|
|
goto more;
|
|
}
|
|
break;
|
|
case KEY_BUFFER:
|
|
small = 0;
|
|
if(BuffYes())
|
|
exec_kettei();
|
|
ChangeBuffMode();
|
|
disp_mode();
|
|
break;
|
|
case KEY_HA_KET:
|
|
small = 0;
|
|
if(!IsCflag()) {
|
|
if(cv->Imode != MODE_HALPHA || BuffYes()) {
|
|
if(BuffYes()) {
|
|
exec_kettei();
|
|
ChangeBuffMode();
|
|
}
|
|
if(cv->Imode != MODE_HALPHA)
|
|
exec_mode(KEY_HALPHA);
|
|
disp_mode();
|
|
}
|
|
} else if((inc = get_pseq()) != 0)
|
|
exec_ctrl(inc);
|
|
break;
|
|
case KEY_FLUSH:
|
|
small = 0;
|
|
if(!IsCflag()) {
|
|
exec_kettei();
|
|
} else if((inc = get_pseq()) != 0)
|
|
exec_ctrl(inc);
|
|
break;
|
|
default:
|
|
small = 0;
|
|
if((inc = get_pseq()) != 0)
|
|
exec_ctrl(inc);
|
|
break;
|
|
}
|
|
if(keyvalue == KEY_CONV) {
|
|
if(!no_flush)
|
|
exec_kettei();
|
|
convertflag = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
save_obuf() {
|
|
Conversion* cv;
|
|
int i, cur;
|
|
|
|
cv = GetConversion();
|
|
|
|
if(cv->out_point < cv->out_epoint) {
|
|
|
|
cur = cv->out_point;
|
|
if(!(cv->out_mode[cur] & OMODE_MASK)) {
|
|
chhstr(cv->Halpha, cv->out_buf, cv->out_mode, cur);
|
|
cv->ha_epoint = wslen(cv->Halpha);
|
|
}
|
|
cv->ha_point = getipos(cur);
|
|
hs_point = 0;
|
|
for(i = cv->ha_point; i < cv->ha_epoint; i++)
|
|
hsave_buf[hs_point++] = cv->Halpha[i];
|
|
hsave_buf[hs_point] = '\0';
|
|
|
|
os_point = 0;
|
|
for(i = cv->out_point; i < cv->out_epoint; i++) {
|
|
osave_buf[os_point] = cv->out_buf[i];
|
|
osave_mode[os_point] = cv->out_mode[i];
|
|
isave_mode[os_point] = cv->in_mode[i];
|
|
os_point++;
|
|
}
|
|
osave_buf[os_point] = '\0';
|
|
}
|
|
}
|
|
|
|
restore_obuf() {
|
|
Conversion* cv;
|
|
int i;
|
|
|
|
cv = GetConversion();
|
|
|
|
cv->out_epoint = cv->out_point;
|
|
cv->ha_epoint = cv->ha_point;
|
|
|
|
if(os_point > 0) {
|
|
for(i = 0; i < (unsigned int)os_point; i++) {
|
|
cv->out_buf[cv->out_epoint] = osave_buf[i];
|
|
cv->out_mode[cv->out_epoint] = osave_mode[i];
|
|
cv->in_mode[cv->out_epoint] = isave_mode[i];
|
|
cv->out_epoint++;
|
|
}
|
|
cv->out_buf[cv->out_epoint] = '\0';
|
|
for(i = 0; i < (unsigned int)hs_point; i++)
|
|
cv->Halpha[cv->ha_epoint++] = hsave_buf[i];
|
|
cv->Halpha[cv->ha_epoint] = '\0';
|
|
}
|
|
}
|
|
|
|
exec_ctrl(c) int c;
|
|
{
|
|
Conversion* cv;
|
|
wchar16_t s[3];
|
|
extern wchar16_t pars_seq[];
|
|
|
|
cv = GetConversion();
|
|
|
|
*s = c;
|
|
s[1] = 0;
|
|
exec_kettei();
|
|
if(c == ' ' && keyvalue == KEY_HENKAN && cv->Imode & MODE_ZEN) {
|
|
s[0] = 0xa1a1;
|
|
s[1] = 0;
|
|
master_write(s, 1);
|
|
} else
|
|
master_write(s, 1);
|
|
|
|
if(IsGoto(c) && (BuffYes() || cv->Imode != MODE_HALPHA)) {
|
|
cv->BuffMode = UNBUFF;
|
|
cv->Imode = MODE_HALPHA;
|
|
disp_mode();
|
|
sj3_rkebell(0);
|
|
}
|
|
|
|
if(IsTrap(c)) {
|
|
*s = inkey();
|
|
if(keyvalue != KEY_NORMAL)
|
|
*s = pars_seq[0];
|
|
master_write(s, 1);
|
|
}
|
|
}
|
|
|
|
exec_mode(key) int key;
|
|
{
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
if(key == KEY_MUHENKAN)
|
|
key = eval_muhenkan();
|
|
if(key == KEY_CODE) {
|
|
if(cv->Imode == MODE_CODE)
|
|
ChangeCode();
|
|
else
|
|
cv->Imode = MODE_CODE;
|
|
} else
|
|
cv->Imode = eval_mode(key);
|
|
}
|
|
|
|
toggle_mode(mod) int mod;
|
|
{
|
|
int value;
|
|
|
|
switch(mod) {
|
|
case MODE_ZHIRA:
|
|
value = KEY_ZKATA;
|
|
break;
|
|
case MODE_ZKATA:
|
|
value = KEY_HKATA;
|
|
break;
|
|
case MODE_HKATA:
|
|
value = KEY_ZALPHA;
|
|
break;
|
|
case MODE_ZALPHA:
|
|
value = KEY_HALPHA;
|
|
break;
|
|
default:
|
|
value = KEY_ZHIRA;
|
|
break;
|
|
}
|
|
return (value);
|
|
}
|
|
|
|
eval_mode(key) int key;
|
|
{
|
|
int mod;
|
|
|
|
switch(key) {
|
|
case KEY_ZHIRA:
|
|
mod = MODE_ZHIRA;
|
|
break;
|
|
case KEY_ZKATA:
|
|
mod = MODE_ZKATA;
|
|
break;
|
|
case KEY_HKATA:
|
|
mod = MODE_HKATA;
|
|
break;
|
|
case KEY_ZALPHA:
|
|
mod = MODE_ZALPHA;
|
|
break;
|
|
default:
|
|
mod = MODE_HALPHA;
|
|
break;
|
|
}
|
|
return (mod);
|
|
}
|
|
|
|
IsESC(c)
|
|
wchar16_t c;
|
|
{
|
|
if(c == ESC)
|
|
return (1);
|
|
else
|
|
return (0);
|
|
}
|
|
|
|
Strncpy(d, s, len)
|
|
wchar16_t* d,
|
|
*s;
|
|
int len;
|
|
{
|
|
if((len > 0) && (s != (wchar16_t*)NULL))
|
|
(void)wsncpy(d, s, len);
|
|
}
|
|
|
|
is_bsdel(c) int c;
|
|
{
|
|
if(is_bs(c) || is_del(c))
|
|
return (1);
|
|
else
|
|
return (0);
|
|
}
|
|
|
|
clear_del() {
|
|
delkey = -1;
|
|
}
|
|
|
|
set_bs(c) int c;
|
|
{
|
|
bskey = c;
|
|
}
|
|
|
|
set_del(c) int c;
|
|
{
|
|
delkey = c;
|
|
}
|
|
|
|
is_bs(c) int c;
|
|
{
|
|
if(c == bskey)
|
|
return (1);
|
|
else
|
|
return (0);
|
|
}
|
|
|
|
is_del(c) int c;
|
|
{
|
|
if(c == delkey)
|
|
return (1);
|
|
else
|
|
return (0);
|
|
}
|
|
|
|
static Conversion* saved_conversion;
|
|
|
|
SaveConversion() {
|
|
saved_conversion = GetConversion();
|
|
}
|
|
|
|
AnotherConversion() {
|
|
if(saved_conversion == GetConversion())
|
|
return (0);
|
|
else
|
|
return (1);
|
|
}
|