/*

* 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.

*

*/

/*

* $SonyRCSfile: douon.c,v $

* $SonyRevision: 1.2 $

* $SonyDate: 1996/02/23 11:04:02 $

*/

#include "common.h"

#include "key.h"

#include "wchar16.h"

#define DNUM 5

static int Dcount;

static int Dpoint;

static struct douon_sj3 HenkanDouon[DOUON_N];

static wchar16_t Dkanji[BUFFLENGTH * 2];

void go_gakusyuu();

SJ_getdouon (s, d, n, choice, reconv)

wchar16_t *s;

struct douon_sj3 *d;

int n;

int choice;

int reconv;

{

int len;

Dcount = SJ2_getdouon (s, d, n, choice, reconv);

if (Dcount < 0 && !dconnect(1))

Dcount = SJ2_getdouon (s, d, n, choice, reconv);

if (Dcount <= 0) {

Dcount = 1;

len = wslen (s);

Strncpy ((char *)d[0].ddata, s, len);

d[0].dlen = wcbyte(s);

d[0].wlen = len;

return(0);

} else

return(1);

}

exec_douon ()

{

Conversion *cv;

int val;

cv = GetConversion ();

if (cv->CurBun == -1) {

cv->CurBun = 0;

Rdisp ();

}

cv->PreBun = cv->CurBun;

if (cv->Bkettei[cv->CurBun] & Bmuhenkan)

val = Sdouon (2);

else

val = Sdouon (1);

if (!val)

Rdisp ();

}

wrap_douon (back)

int back;

{

Conversion *cv;

int val;

cv = current_conversion;

if (cv->CurBun == -1) {

cv->CurBun = 0;

Rdisp ();

}

cv->PreBun = cv->CurBun;

if (cv->Dflag == cv->CurBun)

val = Rdouon (back);

else {

val = Sdouon (2);

cv->Dflag = cv->CurBun;

}

if (!val)

Rdisp ();

}

Cdouon (yomi, gnum)

wchar16_t *yomi;

int gnum;

{

int i, j;

int len;

wchar16_t *s;

int dispnum;

int num;

int displen;

int base;

char tmp[BUFFLENGTH], tmp2[BUFFLENGTH * 2];

wchar16_t wtmp[BUFFLENGTH], wtmp2[BUFFLENGTH * 2];

int gakusyuu;

unsigned short row, col;

Conversion *cv;

cv = current_conversion;

gakusyuu = SJ_getdouon (yomi, HenkanDouon, gnum, 0, 0);

dispnum = DNUM;

if (dispnum > Dcount)

j = Dcount;

else

j = dispnum;

len = 0;

for (i = 0 ; i < j ; i ++)

len += HenkanDouon[i].dlen;

len /= j;

if (len < 1)

len = 1;

len += 6;

sprintf (tmp, "%d/%d ", Dcount, Dcount);

displen = cv->column - strlen (tmp) - 1;

if (displen < 1)

displen = 1;

num = displen / len;

if (num < 1)

num = 1;

if (num < dispnum && num > 0)

dispnum = num;

for (i = 0 ; ; ) {

if (i >= Dcount)

i = 0;

StartGuide (&row, &col);

Clear_EOL ();

base = i;

sprintf (tmp, "%d/%d", i + 1, Dcount);

(void) mbstowcs(wtmp, tmp, BUFFLENGTH);

printR (wtmp);

put_space (1);

for (j = 0 ; j < dispnum ; j ++, i ++) {

if (i >= Dcount)

break;

len = HenkanDouon[i].dlen;

if (len > displen)

len = displen;

s = (wchar16_t *)HenkanDouon[i].ddata;

Strncpy (wtmp, s, HenkanDouon[i].wlen);

wtmp[HenkanDouon[i].wlen] = '\0';

(void) wcstombs(tmp, wtmp, BUFFLENGTH);

sprintf (tmp2, "[%d] %s ", j+1, tmp);

(void) mbstowcs(wtmp2, tmp2, BUFFLENGTH);

SJ_print (wtmp2);

}

EndGuide (row, col);

Flush ();

num = Dselect (j);

if (num == 0)

continue;

else if (num == -1) {

if ((i >= Dcount) && ((Dcount % dispnum) != 0))

i = Dcount - (Dcount % dispnum);

else

i -= dispnum;

i -= dispnum;

if (i < 0) {

if (Dcount > dispnum) {

if ((Dcount % dispnum) == 0)

i = Dcount - dispnum;

else

i = Dcount - (Dcount % dispnum);

}

else

i = 0;

}

continue;

}

else if (num > j) {

disp_mode ();

return (FALSE);

}

else

break;

}

disp_mode ();

Dpoint = base + num - 1;

len = HenkanDouon[Dpoint].dlen;

s = (wchar16_t *)HenkanDouon[Dpoint].ddata;

Strncpy (Dkanji, s, HenkanDouon[Dpoint].wlen);

Dkanji[HenkanDouon[Dpoint].wlen] = '\0';

if (HenkanDouon[Dpoint].valid)

PushGD (gnum, &HenkanDouon[Dpoint].dcid);

if (gakusyuu)

if (HenkanDouon[Dpoint].valid)

SJ2_study (&HenkanDouon[Dpoint].dcid);

else

SJ2_toroku(yomi, HenkanDouon[Dpoint].ddata, SJ3_H_NRMNOUN);

return (TRUE);

}

Dselect (lim)

int lim;

{

extern int keyvalue;

int c, num;

char s[2];

SaveConversion ();

while ((c = inkey ()) != EOF) {

if (AnotherConversion ()) {

unget_key (c);

break;

}

if (keyvalue == KEY_KETTEI)

break;

else if (keyvalue == KEY_HENKAN || keyvalue == KEY_RIGHT)

return (0);

else if (c == ' ')

return (0);

else if (keyvalue == KEY_MUHENKAN || keyvalue == KEY_LEFT

|| is_bsdel (c))

return (-1);

else if (WcIsASCII(c) && isdigit (WcLowByte(c))) {

*s = c;

s[1] = '\0';

num = atoi (s);

if (num > 0 && num <= lim)

return (num);

}

else if (keyvalue != KEY_NORMAL)

break;

else if (keyvalue == KEY_NORMAL && IsESC (c))

break;

}

return (lim + 1);

}

Gdouon (yomi, num, choice, reconv)

wchar16_t *yomi;

int num;

int choice;

int reconv;

{

int len;

wchar16_t *s;

SJ_getdouon (yomi, HenkanDouon, num, choice, reconv);

Dpoint = 0;

len = HenkanDouon[Dpoint].wlen;

s = (wchar16_t *)HenkanDouon[Dpoint].ddata;

Strncpy (Dkanji, s, len);

Dkanji[len] = '\0';

if (HenkanDouon[Dpoint].valid)

PushGD (num, &HenkanDouon[Dpoint].dcid);

}

Sdouon (Choice)

int Choice;

{

Conversion *cv;

int i, j;

int len;

wchar16_t yomi[BUFFLENGTH * 2];

int count;

cv = current_conversion;

count = 0;

if (Choice == 0)

i = cv->PreBun;

else

i = cv->CurBun;

top:

if ((len = load_bun(i, yomi, MODE_ZHIRA)) <= 0) {

cv->Bkettei[i] |= Bmuhenkan;

cv->Bkettei[i] &= ~Bhenkan;

cv->Pkettei[i] = MODE_ZHIRA;

*Dkanji = '\0';

goto null;

}

else if (len > DLEN) {

cv->Bkettei[i] |= Bmuhenkan;

cv->Bkettei[i] &= ~Bhenkan;

*Dkanji = '\0';

goto null;

}

else if (Choice == 0 && (cv->Bkettei[i] & Bmuhenkan)) {

goto tail;

}

else {

cv->Bkettei[i] |= Bhenkan;

cv->Bkettei[i] &= ~Bmuhenkan;

}

if (Choice == 1) {

if (Cdouon (yomi, i) == FALSE)

return (1);

cv->Pkettei[i] = MODE_ZHIRA;

}

else if (Choice == 2) {

Gdouon (yomi, i, 0, 0);

}

else if (Choice == 3)

Gdouon (yomi, i, count, 1);

else

Gdouon (yomi, i, count, 0);

null:

len = wslen (Dkanji);

if (!(cv->Bkettei[i] & Bedit)) {

if (cv->Enum >= MAXENUM)

return (1);

j = cv->Enum ++;

cv->Edit[i] = j;

cv->Epoint[j] = &(cv->Ebuff[cv->e_point]);

cv->e_point += DLEN;

}

else

j = cv->Edit[i];

if (0 < len && len <= DLEN) {

cv->Bkettei[i] |= Bedit;

cv->Pkettei[i] = MODE_ZHIRA;

}

cv->Elen[j] = len;

wscpy (cv->Epoint[j], Dkanji);

tail:

if (Choice == 0 && i != cv->CurBun) {

i = cv->CurBun;

goto top;

}

if (cv->PreBun == cv->Bnum)

cv->Bkettei[cv->Bnum] = Bend;

return (0);

}

Rdouon (back)

int back;

{

Conversion *cv;

int i, j;

int len;

wchar16_t *s;

cv = current_conversion;

if (Dcount > 0) {

if (back) {

Dpoint --;

if (Dpoint < 0)

Dpoint = Dcount - 1;

}

else {

Dpoint ++;

if (Dpoint >= Dcount)

Dpoint = 0;

}

len = HenkanDouon[Dpoint].wlen;

s = (wchar16_t *)HenkanDouon[Dpoint].ddata;

Strncpy (Dkanji, s, len);

Dkanji[len] = '\0';

i = cv->CurBun;

j = cv->Edit[i];

cv->Elen[j] = len;

wscpy (cv->Epoint[j], Dkanji);

return (0);

}

return (1);

}

Bkanji (kanji)

wchar16_t *kanji;

{

Conversion *cv;

int i;

int plen, len;

wchar16_t *s;

cv = current_conversion;

s = kanji;

*s = '\0';

plen = 0;

for (i = 0 ; i < cv->Bnum ; i ++) {

if ((len = Bstr (i, s)) <= 0)

continue;

s += len;

plen += len;

}

return(plen);

}

struct studyrec Gdata[BUFFLENGTH];

PushGD (num, wordid)

int num;

struct studyrec *wordid;

{

Gdata[num] = *wordid;

}

cl_gakusyuu ()

{

Conversion *cv;

int i, j;

int o_point, n_point;

cv = current_conversion;

for (i = 0 ; i < cv->Bnum ; i ++) {

if (cv->OrgPlen[i] != cv->Plen[i]) {

o_point = n_point = 0;

j = i;

while (j < cv->Bnum) {

o_point += cv->OrgPlen[j];

n_point += cv->Plen[j];

j ++;

if (o_point == n_point)

break;

}

j--;

check_and_gakusyuu (i, j);

i = j;

}

}

}

check_and_gakusyuu (m, n)

int m, n;

{

Conversion *cv;

int i, j;

cv = current_conversion;

i = m;

j = i + 1;

while (j <= n && j < cv->Bnum) {

if (cv->Bkettei[i] & Bedit && !(cv->Bkettei[i] & Bmuhenkan))

go_gakusyuu (i);

i ++;

j ++;

}

}

void

go_gakusyuu (n)

int n;

{

Conversion *cv;

int i, j;

wchar16_t yomi1[BUFFLENGTH], yomi2[BUFFLENGTH];

struct studyrec *gdatap;

int len;

cv = current_conversion;

i = n;

j = i + 1;

if (cv->Pedited[i] == 1 || cv->Pedited[j] == 1)

return;

if ((len = load_bun(i, yomi1, MODE_ZHIRA)) <= 0 && len > DLEN)

return;

if ((len = load_bun(j, yomi2, MODE_ZHIRA)) > DLEN)

return;

if (len <= 0)

gdatap = NULL;

else

gdatap = &Gdata[j];

SJ2_clstudy (yomi1, yomi2, gdatap);

}