452 lines
9.1 KiB
C
452 lines
9.1 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"
|
|
|
|
extern int keyvalue;
|
|
static char rehname[SHORTLENGTH * 2];
|
|
extern char* cur_serv;
|
|
static int dcflag = 0;
|
|
|
|
void disp_version();
|
|
|
|
exec_etc(key) int key;
|
|
{
|
|
unsigned short row, col;
|
|
int inc;
|
|
int chbun;
|
|
int edited;
|
|
int etckey;
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
|
|
edited = 0;
|
|
chbun = 0;
|
|
StartGuide(&row, &col);
|
|
if(key == KEY_ETC) {
|
|
printR(WCGEtc);
|
|
if(cv->column >= MINCOL)
|
|
spaceR(WCGetc);
|
|
Clear_EOL();
|
|
EndGuide(row, col);
|
|
SaveConversion();
|
|
inc = inkey();
|
|
if(AnotherConversion())
|
|
return (KEY_NORMAL);
|
|
cv = GetConversion();
|
|
etckey = etc_map(keyvalue);
|
|
} else {
|
|
EndGuide(row, col);
|
|
etckey = key;
|
|
}
|
|
|
|
switch(etckey) {
|
|
case KEY_NORMAL:
|
|
normal:
|
|
switch(inc) {
|
|
case 'h':
|
|
helplevel();
|
|
break;
|
|
case 't':
|
|
if(!IsCflag())
|
|
chbun = exec_toroku();
|
|
break;
|
|
case 's':
|
|
if(!IsCflag())
|
|
chbun = exec_shoukyo();
|
|
break;
|
|
case 'v':
|
|
case 'd':
|
|
disp_version(inc);
|
|
break;
|
|
case 'w':
|
|
change_weight();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case KEY_HELP:
|
|
helplevel();
|
|
break;
|
|
case KEY_TOROKU:
|
|
if(!IsCflag())
|
|
chbun = exec_toroku();
|
|
break;
|
|
case KEY_SHOUKYO:
|
|
if(!IsCflag())
|
|
chbun = exec_shoukyo();
|
|
break;
|
|
case KEY_SJRC:
|
|
if(IsCflag())
|
|
exec_sjrc();
|
|
break;
|
|
case KEY_EDIT:
|
|
if(IsHenkan()) {
|
|
if(cv->CurBun < 0) {
|
|
cv->CurBun = 0;
|
|
Bdisp(1);
|
|
}
|
|
edited = exec_edit();
|
|
}
|
|
break;
|
|
case KEY_RECONNECT:
|
|
if(reconnect() && IsHenkan()) {
|
|
EndGuide(row, col);
|
|
Clear_EOL();
|
|
Ccheck();
|
|
Cclear(1);
|
|
ResetHenkan();
|
|
vprintU(cv->out_buf, 1);
|
|
cv->Kanji = 0;
|
|
return (KEY_NORMAL);
|
|
}
|
|
break;
|
|
case KEY_ETC:
|
|
break;
|
|
default:
|
|
if((inc = write_pseq(2)) != 0)
|
|
goto normal;
|
|
return (etckey);
|
|
break;
|
|
}
|
|
|
|
EndGuide(row, col);
|
|
if(edited) {
|
|
if(!Sdouon(3))
|
|
Rdisp();
|
|
}
|
|
if(chbun)
|
|
Ssbun(1);
|
|
return (KEY_NORMAL);
|
|
}
|
|
|
|
Ssbun(flag) int flag;
|
|
{
|
|
Conversion* cv;
|
|
static short ScurBun, SpreBun;
|
|
|
|
cv = GetConversion();
|
|
if(flag) {
|
|
if(cv->CurBun != ScurBun || cv->PreBun != SpreBun) {
|
|
cv->CurBun = ScurBun;
|
|
cv->PreBun = SpreBun;
|
|
Bdisp();
|
|
}
|
|
} else {
|
|
ScurBun = cv->CurBun;
|
|
SpreBun = cv->PreBun;
|
|
}
|
|
}
|
|
|
|
etc_map(key) int key;
|
|
{
|
|
extern int u_etckeys;
|
|
extern int Uetckey[], Uetcval[];
|
|
int i;
|
|
int val;
|
|
|
|
for(i = 0; i < u_etckeys; i++) {
|
|
if(key == Uetckey[i])
|
|
return (Uetcval[i]);
|
|
}
|
|
|
|
switch(key) {
|
|
case KEY_HENKAN:
|
|
val = KEY_TOROKU;
|
|
break;
|
|
case KEY_MUHENKAN:
|
|
val = KEY_SHOUKYO;
|
|
break;
|
|
case KEY_ETC:
|
|
val = KEY_HELP;
|
|
break;
|
|
case KEY_KETTEI:
|
|
val = KEY_SJRC;
|
|
break;
|
|
case KEY_CODE:
|
|
val = KEY_EDIT;
|
|
break;
|
|
case KEY_HALPHA:
|
|
val = KEY_RECONNECT;
|
|
break;
|
|
default:
|
|
val = KEY_NORMAL;
|
|
break;
|
|
}
|
|
return (val);
|
|
}
|
|
|
|
helplevel() {
|
|
wchar16_t wtmp[BUFFLENGTH];
|
|
unsigned char mtmp[BUFFLENGTH];
|
|
unsigned char tmp[BUFFLENGTH];
|
|
Conversion* cv;
|
|
|
|
cv = GetConversion();
|
|
|
|
if(Hlevel == 1 && cv->column >= MINCOL) {
|
|
HHlevel = 2;
|
|
Hlevel = 2;
|
|
(void)wcstombs((char*)mtmp, WCMHelp, BUFFLENGTH);
|
|
sprintf((char*)tmp, (char*)mtmp, "on");
|
|
(void)mbstowcs(wtmp, (char*)tmp, BUFFLENGTH);
|
|
} else {
|
|
HHlevel = 1;
|
|
Hlevel = 1;
|
|
(void)wcstombs((char*)mtmp, WCMHelp, BUFFLENGTH);
|
|
sprintf((char*)tmp, (char*)mtmp, "off");
|
|
(void)mbstowcs(wtmp, (char*)tmp, BUFFLENGTH);
|
|
}
|
|
guide_print_pause(WCGHelp, wtmp);
|
|
}
|
|
|
|
void
|
|
disp_version(c) int c;
|
|
{
|
|
extern char *Version, *Copyright, *Date;
|
|
char tmp[BUFFLENGTH];
|
|
|
|
wchar16_t wtmp[BUFFLENGTH];
|
|
|
|
if(c == 'v')
|
|
sprintf(tmp, "%s, %s ", Version, Copyright);
|
|
else if(c == 'd')
|
|
sprintf(tmp, "%s ", Date);
|
|
else
|
|
return;
|
|
(void)mbstowcs(wtmp, tmp, BUFFLENGTH);
|
|
guide_print_pause(0, wtmp);
|
|
}
|
|
|
|
exec_sjrc() {
|
|
extern char RCfile[];
|
|
char tmp[BUFFLENGTH];
|
|
unsigned char SUCCorFAIL[BUFFLENGTH];
|
|
wchar16_t wtmp[BUFFLENGTH];
|
|
|
|
if(*RCfile == (char)NULL) {
|
|
getsjrc();
|
|
if(*RCfile == (char)NULL) {
|
|
(void)wcstombs((char*)SUCCorFAIL, WCNOTHsjrc, BUFFLENGTH);
|
|
sprintf((char*)tmp, (char*)SUCCorFAIL);
|
|
(void)mbstowcs(wtmp, tmp, BUFFLENGTH);
|
|
} else {
|
|
(void)wcstombs((char*)SUCCorFAIL, WCSUCCsjrc, BUFFLENGTH);
|
|
sprintf(tmp, "%s %s ", RCfile, SUCCorFAIL);
|
|
(void)mbstowcs(wtmp, tmp, BUFFLENGTH);
|
|
}
|
|
} else {
|
|
if(setrc() == TRUE) {
|
|
(void)wcstombs((char*)SUCCorFAIL, WCSUCCsjrc, BUFFLENGTH);
|
|
} else {
|
|
(void)wcstombs((char*)SUCCorFAIL, WCFAILsjrc, BUFFLENGTH);
|
|
}
|
|
sprintf(tmp, "%s %s ", RCfile, SUCCorFAIL);
|
|
(void)mbstowcs(wtmp, tmp, BUFFLENGTH);
|
|
}
|
|
guide_print_pause(0, wtmp);
|
|
}
|
|
|
|
static int weight = 3;
|
|
static int seed = 100000;
|
|
|
|
change_weight() {
|
|
int c;
|
|
char s[2];
|
|
char tmp[BUFFLENGTH];
|
|
unsigned char mtmp[BUFFLENGTH];
|
|
wchar16_t wtmp[BUFFLENGTH];
|
|
|
|
(void)wcstombs((char*)mtmp, WCWeight_mes, BUFFLENGTH);
|
|
sprintf(tmp, (char*)mtmp, weight);
|
|
(void)mbstowcs(wtmp, tmp, BUFFLENGTH);
|
|
c = guide_print_pause(0, wtmp);
|
|
|
|
if(isdigit(c) && (c != '0')) {
|
|
s[0] = c;
|
|
s[1] = '\0';
|
|
weight = atoi(s);
|
|
}
|
|
}
|
|
|
|
UsecWeight(sw) int sw;
|
|
{
|
|
|
|
if(sw)
|
|
return (seed);
|
|
else
|
|
return (seed * weight);
|
|
}
|
|
|
|
dconnect(aflag) int aflag;
|
|
{
|
|
int err;
|
|
char tmp[BUFFLENGTH];
|
|
wchar16_t wtmp[BUFFLENGTH];
|
|
unsigned char dtmp[BUFFLENGTH];
|
|
|
|
if(!dcflag) {
|
|
(void)wcstombs((char*)dtmp, WCDiscon, BUFFLENGTH);
|
|
sprintf(tmp, (char*)dtmp, cur_serv);
|
|
beep();
|
|
(void)mbstowcs(wtmp, tmp, BUFFLENGTH);
|
|
guide_print_pause(0, wtmp);
|
|
|
|
if(aflag && keyvalue == KEY_HENKAN) {
|
|
if((err = sj3_autocon()) == 0) {
|
|
(void)wcstombs((char*)dtmp, WCRserv_OK, BUFFLENGTH);
|
|
sprintf(tmp, (char*)dtmp, cur_serv);
|
|
(void)mbstowcs(wtmp, (char*)tmp, BUFFLENGTH);
|
|
guide_print_pause(0, wtmp);
|
|
} else {
|
|
guide_print_pause(WCSpace, WCNconnect);
|
|
dcflag = 1;
|
|
}
|
|
} else
|
|
dcflag = 1;
|
|
disp_mode();
|
|
}
|
|
return (dcflag);
|
|
}
|
|
|
|
set_dcflag(flag) int flag;
|
|
{
|
|
dcflag = flag;
|
|
}
|
|
|
|
IsDcflag() {
|
|
return (dcflag);
|
|
}
|
|
|
|
reconnect() {
|
|
int inc, err;
|
|
char tmp[BUFFLENGTH], *hp;
|
|
char newserv[SHORTLENGTH * 2], *nsp;
|
|
wchar16_t wtmp[BUFFLENGTH];
|
|
unsigned char rtmp[BUFFLENGTH];
|
|
|
|
strncpy(newserv, cur_serv, SHORTLENGTH * 2 - 1);
|
|
newserv[SHORTLENGTH * 2 - 1] = '\0';
|
|
while(1) {
|
|
SaveConversion();
|
|
TopGuide();
|
|
printR(WCGrcon);
|
|
(void)wcstombs((char*)rtmp, WCRserv, BUFFLENGTH);
|
|
sprintf(tmp, (char*)rtmp, newserv);
|
|
(void)mbstowcs(wtmp, tmp, BUFFLENGTH);
|
|
SJ_print(wtmp);
|
|
Clear_EOL();
|
|
Flush();
|
|
nsp = newserv;
|
|
while((inc = inkey()) != EOF) {
|
|
if(AnotherConversion()) {
|
|
unget_key(inc);
|
|
return (0);
|
|
}
|
|
if(keyvalue != KEY_NORMAL && keyvalue != KEY_FLUSH)
|
|
return (0);
|
|
if(inc == '\n' || inc == '\r' || IsESC(inc))
|
|
break;
|
|
if(is_bs(inc) && nsp > newserv) {
|
|
nsp--;
|
|
*nsp = '\0';
|
|
backspace(1);
|
|
Flush();
|
|
} else if(isgraph(inc) &&
|
|
nsp < &newserv[SHORTLENGTH * 2 - 1]) {
|
|
*nsp++ = inc;
|
|
printf("%c", inc);
|
|
Flush();
|
|
} else
|
|
beep();
|
|
}
|
|
if(nsp > newserv) {
|
|
*nsp = '\0';
|
|
strcpy(rehname, newserv);
|
|
cur_serv = rehname;
|
|
} else if(newserv[0] == '\0') {
|
|
strncpy(newserv, cur_serv, SHORTLENGTH * 2 - 1);
|
|
newserv[SHORTLENGTH * 2 - 1] = '\0';
|
|
}
|
|
if((err = SJ2_reconnect()) == 0) {
|
|
TopGuide();
|
|
printR(WCGrcon);
|
|
(void)wcstombs((char*)rtmp, WCRserv_OK, BUFFLENGTH);
|
|
sprintf(tmp, (char*)rtmp, newserv);
|
|
(void)mbstowcs(wtmp, tmp, BUFFLENGTH);
|
|
SJ_print(wtmp);
|
|
Clear_EOL();
|
|
Flush();
|
|
set_dcflag(0);
|
|
inc = inkey();
|
|
if(AnotherConversion())
|
|
unget_key(inc);
|
|
break;
|
|
} else {
|
|
TopGuide();
|
|
printR(WCGrcon);
|
|
SJ_print(WCSpace);
|
|
sj_check_error(err);
|
|
SJ_print(WCContinue);
|
|
Clear_EOL();
|
|
Backspace();
|
|
Flush();
|
|
inc = inkey();
|
|
if(AnotherConversion()) {
|
|
unget_key(inc);
|
|
set_dcflag(1);
|
|
break;
|
|
}
|
|
if(inc == 'n' || inc == 'N' || inc == EOF) {
|
|
set_dcflag(1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
guide_print_pause(s1, s2)
|
|
wchar16_t* s1,
|
|
*s2;
|
|
{
|
|
int c;
|
|
|
|
guide_print(s1, s2);
|
|
SaveConversion();
|
|
c = inkey();
|
|
if(AnotherConversion()) {
|
|
unget_key(c);
|
|
return (EOF);
|
|
}
|
|
return (c);
|
|
}
|