void disp_pho_sub(GtkWidget *label, int index, char *pho)
{
if (!label)
return;
if (index>=text_pho_N)
return;
if (pho[0]==' ' && !pin_juyin) {
u8cpy(text_pho[index], _(_L(" ")));
}
else {
u8cpy(text_pho[index], pho);
}
#if UNIX
char s[text_pho_N * CH_SZ+1];
#else
char *s = new char[text_pho_N * CH_SZ+1];
#endif
int tn = 0;
int i;
for(i=0; i < text_pho_N; i++) {
int n = utf8cpy(s + tn, text_pho[i]);
tn += n;
}
// gtk_widget_show(label);
gtk_label_set_text(GTK_LABEL(label), s);
#if WIN32
delete s;
#endif
}
gboolean full_char_proc(KeySym keysym)
{
char *s = half_char_to_full_char(keysym);
if (!s)
return 0;
char tt[CH_SZ+1];
utf8cpy(tt, s);
if (current_CS->im_state == HIME_STATE_ENG_FULL) {
send_text(tt);
return 1;
}
if (current_method_type() == 6 && current_CS->im_state == HIME_STATE_CHINESE)
add_to_tsin_buf_str(tt);
else
if (gtab_phrase_on() && ggg.gbufN)
insert_gbuf_nokey(tt);
else
send_text(tt);
return 1;
}
void disp_pho_sub(GtkWidget *label, int index, char *pho)
{
if (!label)
return;
if (index>=text_pho_N)
return;
if (pho[0]==' ' && !pin_juyin) {
u8cpy(text_pho[index], " "); /* Full width space */
}
else {
u8cpy(text_pho[index], pho);
}
char s[text_pho_N * CH_SZ+1];
int tn = 0;
int i;
for(i=0; i < text_pho_N; i++) {
int n = utf8cpy(s + tn, text_pho[i]);
tn += n;
}
// gtk_widget_show(label);
gtk_label_set_text(GTK_LABEL(label), s);
}
bool menu_animation_ticker(const menu_animation_ctx_ticker_t *ticker)
{
size_t str_len = utf8len(ticker->str);
size_t offset = 0;
if ((size_t)str_len <= ticker->len)
{
utf8cpy(ticker->s,
PATH_MAX_LENGTH,
ticker->str,
ticker->len);
return true;
}
if (!ticker->selected)
{
utf8cpy(ticker->s, PATH_MAX_LENGTH, ticker->str, ticker->len - 3);
strlcat(ticker->s, "...", PATH_MAX_LENGTH);
return true;
}
if (str_len > ticker->len)
menu_animation_ticker_generic(
ticker->idx,
ticker->len,
&offset,
&str_len);
utf8cpy(
ticker->s,
PATH_MAX_LENGTH,
utf8skip(ticker->str, offset),
str_len);
animation_is_active = true;
return true;
}
static void wsp_str(WSP_S *wsp, int wspN, char *out)
{
int i;
int ofs=0;
for(i=0;i<wspN;i++) {
// utf8_putchar(wsp[i].ch);
int n = utf8cpy(out+ofs, wsp[i].ch);
ofs+=n;
}
// out[ofs]=0;
// dbg(" c_len:%d wsp %s\n", c_len, out);
}
char *pho_idx_str2(int idx, int *is_phrase)
{
static char tt[CH_SZ+1];
unsigned char *p = (u_char *)ch_pho[idx].ch;
if (*p==PHO_PHRASE_ESCAPE) {
p++;
int ofs = (*p) | *(p+1)<<8 | *(p+2)<<16;
// dbg("idx:%d ofs:%d %s\n", idx, ofs, pho_phrase_area+ofs);
*is_phrase = TRUE;
return pho_phrase_area+ofs;
} else {
*is_phrase = FALSE;
utf8cpy(tt, (char *)p);
return tt;
}
}
static void DispInArea()
{
int i;
// hide_gtab_pre_sel();
// dbg("sel1st:%d\n", ggg.sel1st_i);
if (hime_display_on_the_spot_key()) {
if (gwin_gtab && GTK_WIDGET_VISIBLE(gwin_gtab) && poo.same_pho_query_state == SAME_PHO_QUERY_none)
hide_win_gtab();
return;
}
char tt[128];
int ttN=0;
if (win_gtab_max_key_press < ggg.ci)
win_gtab_max_key_press = ggg.ci;
for(i=0;i<ggg.ci;i++) {
char *p=(char *)&cur_inmd->keyname[ggg.inch[i] * CH_SZ];
int len;
if (*p & 0x80)
len=utf8cpy(tt+ttN, p);
else {
len = strlen(p);
strcpy(tt+ttN, p);
}
ttN+=len;
}
tt[ttN]=0;
gtab_disp_empty(tt, win_gtab_max_key_press - i);
disp_gtab(tt);
minimize_win_gtab();
}
inline static token_t lexstring(secd_parser_t *p) {
size_t bufsize = 32; /* initial size since string size is not limited */
size_t read_count = 0;
/* to be freed after p->strtok is consumed: */
cell_t *strbuf = new_string_of_size(p->secd, bufsize);
share_cell(p->secd, strbuf);
char *buf = strmem(strbuf);
while (1) {
nextchar(p);
switch (p->lc) {
case '\\':
nextchar(p);
switch (p->lc) {
case 'a' : buf[read_count++] = '\x07'; break;
case 'b' : buf[read_count++] = '\x08'; break;
case 't' : buf[read_count++] = '\x09'; break;
case 'n' : buf[read_count++] = '\x0A'; break;
case 'x': {
char hexbuf[10];
char *hxb = hexbuf;
nextchar(p);
if (!isxdigit(p->lc))
goto cleanup_and_exit;
do {
*hxb++ = p->lc;
nextchar(p);
} while ((hxb - hexbuf < 9) && isxdigit(p->lc));
if (p->lc != ';')
goto cleanup_and_exit;
*hxb = '\0';
unichar_t charcode = (int)strtol(hexbuf, NULL, 16);
char *after = utf8cpy(buf + read_count, charcode);
if (!after)
goto cleanup_and_exit;
read_count = after - buf;
} break;
default:
buf[read_count++] = p->lc;
}
break;
case '"':
nextchar(p);
buf[read_count] = '\0';
p->strtok = strbuf; /* don't forget to free */
return (p->token = TOK_STR);
default:
buf[read_count] = p->lc;
++read_count;
}
if (read_count + 4 >= bufsize) { // +4 because of utf8cpy
/* reallocate */
size_t newbufsize = 2 * bufsize;
cell_t *newstrbuf = new_string_of_size(p->secd, newbufsize);
if (is_error(newstrbuf)) {
secd_errorf(p->secd, "lexstring: not enough memory for a string\n");
goto cleanup_and_exit;
}
//errorf(";# reallocating string to %lu", newbufsize);
char *newbuf = strmem(newstrbuf);
memcpy(newbuf, buf, bufsize);
assign_cell(p->secd, &strbuf, newstrbuf);
buf = newbuf;
bufsize = newbufsize;
}
}
cleanup_and_exit:
drop_cell(p->secd, strbuf);
return (p->token = TOK_ERR);
}
void pho_load()
{
char *pho_tab;
if (is_chs) {
pho_tab = phonetic_huge_tab ? s_pho_huge_tab:s_pho_normal_tab;
} else
pho_tab = phonetic_huge_tab ? pho_huge_tab:pho_normal_tab;
if (!getenv("GCIN_TABLE_DIR") && phonetic_char_dynamic_sequence) {
get_gcin_user_fname(pho_tab, phofname);
#if UNIX
if (access(phofname, W_OK) < 0){
#else
if (_access(phofname, 02) < 0){
#endif
char sys_file[256], vv[256];
get_sys_table_file_name(sys_file, pho_tab);
#if UNIX
sprintf(vv,"cp %s %s\n", sys_file, phofname);
system(vv);
#else
CopyFileA(sys_file, phofname, FALSE);
#endif
}
} else {
get_sys_table_file_name(pho_tab, phofname);
dbg("use system's pho, no dynamic adj\n");
}
update_table_file(pho_tab, 4);
FILE *fr;
if ((fr=fopen(phofname,"rb"))==NULL)
p_err("err %s\n", phofname);
fread(&idxnum_pho,sizeof(u_short),1,fr);
fread(&idxnum_pho,sizeof(u_short),1,fr);
fread(&ch_phoN,sizeof(int),1,fr);
fread(&pho_phrase_area_sz, sizeof(pho_phrase_area_sz), 1,fr);
if (idx_pho)
free(idx_pho);
idx_pho = tmalloc(PHO_IDX, idxnum_pho + 1);
fread(idx_pho, sizeof(PHO_IDX), idxnum_pho, fr);
ch_pho_ofs = ftell(fr);
if (ch_pho)
free(ch_pho);
if (!(ch_pho=tmalloc(PHO_ITEM, ch_phoN)))
p_err("malloc error");
fread(ch_pho,sizeof(PHO_ITEM), ch_phoN, fr);
// dbg("ch_phoN:%d %d\n", ch_phoN, idxnum_pho);
if (pho_phrase_area) {
free(pho_phrase_area);
pho_phrase_area = NULL;
}
if (pho_phrase_area_sz) {
pho_phrase_area = tmalloc(char, pho_phrase_area_sz);
fread(pho_phrase_area, 1,pho_phrase_area_sz, fr);
#if 0
dbg("pho_phrase loaded %d\n", pho_phrase_area_sz);
int i;
for(i=0; i <pho_phrase_area_sz; i+=strlen(pho_phrase_area+i)+1) {
dbg(" %s\n", pho_phrase_area+i);
}
#endif
}
fclose(fr);
idx_pho[idxnum_pho].key=0xffff;
idx_pho[idxnum_pho].start=ch_phoN;
#if 0
int i;
for(i=0; i <ch_phoN; i++) {
char tt[5];
utf8cpy(tt, ch_pho[i].ch);
dbg("oooo %s\n", tt);
}
#endif
}
void lookup_gtab_out(char *ch, char *out)
{
char tt[CH_SZ+1];
utf8cpy(tt, ch);
lookup_gtabn(tt, out);
}
bool menu_animation_ctl(enum menu_animation_ctl_state state, void *data)
{
static menu_animation_t anim;
static retro_time_t cur_time = 0;
static retro_time_t old_time = 0;
static float delta_time = 0.0f;
static bool animation_is_active = false;
switch (state)
{
case MENU_ANIMATION_CTL_DEINIT:
{
size_t i;
for (i = 0; i < anim.size; i++)
{
if (anim.list[i].subject)
anim.list[i].subject = NULL;
}
free(anim.list);
memset(&anim, 0, sizeof(menu_animation_t));
}
cur_time = 0;
old_time = 0;
delta_time = 0.0f;
break;
case MENU_ANIMATION_CTL_IS_ACTIVE:
return animation_is_active;
case MENU_ANIMATION_CTL_CLEAR_ACTIVE:
animation_is_active = false;
break;
case MENU_ANIMATION_CTL_SET_ACTIVE:
animation_is_active = true;
break;
case MENU_ANIMATION_CTL_DELTA_TIME:
{
float *ptr = (float*)data;
if (!ptr)
return false;
*ptr = delta_time;
}
break;
case MENU_ANIMATION_CTL_UPDATE_TIME:
{
static retro_time_t last_clock_update = 0;
settings_t *settings = config_get_ptr();
cur_time = cpu_features_get_time_usec();
delta_time = cur_time - old_time;
if (delta_time >= IDEAL_DELTA_TIME* 4)
delta_time = IDEAL_DELTA_TIME * 4;
if (delta_time <= IDEAL_DELTA_TIME / 4)
delta_time = IDEAL_DELTA_TIME / 4;
old_time = cur_time;
if (((cur_time - last_clock_update) > 1000000)
&& settings->menu.timedate_enable)
{
animation_is_active = true;
last_clock_update = cur_time;
}
}
break;
case MENU_ANIMATION_CTL_UPDATE:
{
unsigned i;
unsigned active_tweens = 0;
float *dt = (float*)data;
if (!dt)
return false;
for(i = 0; i < anim.size; i++)
menu_animation_iterate(&anim, i, *dt, &active_tweens);
if (!active_tweens)
{
anim.size = 0;
anim.first_dead = 0;
return false;
}
animation_is_active = true;
}
break;
case MENU_ANIMATION_CTL_KILL_BY_TAG:
{
unsigned i;
menu_animation_ctx_tag_t *tag = (menu_animation_ctx_tag_t*)data;
if (!tag || tag->id == -1)
return false;
for (i = 0; i < anim.size; ++i)
{
if (anim.list[i].tag != tag->id)
continue;
anim.list[i].alive = false;
anim.list[i].subject = NULL;
if (i < anim.first_dead)
anim.first_dead = i;
}
}
break;
case MENU_ANIMATION_CTL_KILL_BY_SUBJECT:
{
unsigned i, j, killed = 0;
menu_animation_ctx_subject_t *subject =
(menu_animation_ctx_subject_t*)data;
float **sub = (float**)subject->data;
for (i = 0; i < anim.size; ++i)
{
if (!anim.list[i].alive)
continue;
for (j = 0; j < subject->count; ++j)
{
if (anim.list[i].subject != sub[j])
continue;
anim.list[i].alive = false;
anim.list[i].subject = NULL;
if (i < anim.first_dead)
anim.first_dead = i;
killed++;
break;
}
}
}
break;
case MENU_ANIMATION_CTL_TICKER:
{
menu_animation_ctx_ticker_t *ticker = (menu_animation_ctx_ticker_t*)
data;
size_t str_len = utf8len(ticker->str);
size_t offset = 0;
if ((size_t)str_len <= ticker->len)
{
utf8cpy(ticker->s,
PATH_MAX_LENGTH,
ticker->str,
ticker->len);
return true;
}
if (!ticker->selected)
{
utf8cpy(ticker->s, PATH_MAX_LENGTH, ticker->str, ticker->len - 3);
strlcat(ticker->s, "...", PATH_MAX_LENGTH);
return true;
}
menu_animation_ticker_generic(
ticker->idx,
ticker->len,
&offset,
&str_len);
utf8cpy(
ticker->s,
PATH_MAX_LENGTH,
utf8skip(ticker->str, offset),
str_len);
animation_is_active = true;
}
break;
case MENU_ANIMATION_CTL_IDEAL_DELTA_TIME_GET:
{
menu_animation_ctx_delta_t *delta =
(menu_animation_ctx_delta_t*)data;
if (!delta)
return false;
delta->ideal = delta->current / IDEAL_DELTA_TIME;
}
break;
case MENU_ANIMATION_CTL_PUSH:
return menu_animation_push(&anim, data);
case MENU_ANIMATION_CTL_NONE:
default:
break;
}
return true;
}
void update_win_kbm()
{
if (!current_CS || !gwin_kbm)
return;
clear_kbm();
if (current_CS->im_state != GCIN_STATE_CHINESE) {
if (current_CS->im_state == GCIN_STATE_DISABLED) {
int i;
for(i=0;i<keysN;i++) {
int j;
for(j=0;j<COLN;j++) {
char kstr[2];
kstr[1]=0;
kstr[0] = keys[i][j].shift_key;
if (keys[i][j].laben) {
if (kstr[0])
gtk_label_set_text(GTK_LABEL(keys[i][j].laben), kstr);
set_label_font_size(keys[i][j].laben, gcin_font_size_win_kbm_en);
}
if (keys[i][j].lab) {
if (kstr[0])
gtk_label_set_text(GTK_LABEL(keys[i][j].lab), _(keys[i][j].enkey));
set_label_font_size(keys[i][j].lab, gcin_font_size_win_kbm_en);
}
}
}
}
goto ret;
}
int i;
switch (current_method_type()) {
case method_type_PHO:
case method_type_TSIN:
for(i=0; i < 128; i++) {
int j;
char tt[64];
int ttN=0;
for(j=0;j<3; j++) {
int num = phkbm.phokbm[i][j].num;
int typ = phkbm.phokbm[i][j].typ;
if (!num)
continue;
ttN+= utf8cpy(&tt[ttN], &pho_chars[typ][num * 3]);
}
if (!ttN)
continue;
set_kbm_key(i, tt);
}
disp_shift_keys();
break;
case method_type_MODULE:
break;
default:
if (!cur_inmd || !cur_inmd->DefChars)
return;
int loop;
for(loop=0;loop<2;loop++)
for(i=127; i > 0; i--) {
char tt[64];
char k=cur_inmd->keymap[i];
if (!k)
continue;
char *keyname = &cur_inmd->keyname[k * CH_SZ];
if (!keyname[0])
continue;
#if 0
if (loop==0 && !(keyname[0]&0x80))
#else
if (loop==0 && !(keyname[0]&0x80) && toupper(i)==toupper(keyname[0]))
#endif
continue;
if (loop==1) {
KEY *p = get_keys_ent(i);
char *t = (char *)gtk_label_get_text(GTK_LABEL(p->lab));
if (t && t[0]) {
continue;
}
}
tt[0]=0;
if (keyname[0] & 128)
utf8cpy(tt, keyname);
else {
tt[1]=0;
memcpy(tt, keyname, 2);
tt[2]=0;
}
// dbg("%c '%s'\n", i, tt);
set_kbm_key(i, tt);
}
disp_shift_keys();
break;
}
ret:
gtk_window_resize(GTK_WINDOW(gwin_kbm), 1, 1);
move_win_kbm();
}
void lookup_gtab(char *ch)
{
char tt[CH_SZ+1];
utf8cpy(tt, ch);
lookup_gtabn(tt, NULL);
}
int tsin_parse_recur(int start, TSIN_PARSE *out,
short *r_match_phr_N, short *r_no_match_ch_N)
{
int plen;
double bestscore = -1;
int bestusecount = 0;
*r_match_phr_N = 0;
*r_no_match_ch_N = tsin_parse_len - start;
for(plen=1; start + plen <= tsin_parse_len && plen <= MAX_PHRASE_LEN; plen++) {
#if DBG
dbg("---- aa st:%d hh plen:%d ", start, plen);utf8_putchar(tss.chpho[start].ch); dbg("\n");
#endif
if (plen > 1) {
if (tsin_is_gtab) {
if (gbuf[start+plen-1].flag & FLAG_CHPHO_PHRASE_USER_HEAD)
break;
} else
if (tss.chpho[start+plen-1].flag & FLAG_CHPHO_PHRASE_USER_HEAD)
break;
}
phokey_t pp[MAX_PHRASE_LEN + 1];
u_int pp32[MAX_PHRASE_LEN + 1];
u_int64_t pp64[MAX_PHRASE_LEN + 1];
int sti, edi;
TSIN_PARSE pbest[MAX_PH_BF_EXT+1];
#define MAXV 1000
int maxusecount = 5-MAXV;
int remlen;
short match_phr_N=0, no_match_ch_N = plen;
void *ppp;
if (ph_key_sz==2)
ppp=pp;
else if (ph_key_sz==4)
ppp=pp32;
else
ppp=pp64;
bzero(pbest, sizeof(TSIN_PARSE) * tsin_parse_len);
pbest[0].len = plen;
pbest[0].start = start;
int i, ofs;
if (tsin_is_gtab)
for(ofs=i=0; i < plen; i++)
ofs += utf8cpy((char *)pbest[0].str + ofs, gbuf[start + i].ch);
else
for(ofs=i=0; i < plen; i++)
ofs += utf8cpy((char *)pbest[0].str + ofs, tss.chpho[start + i].ch);
#if DBG
dbg("st:%d hh plen:%d ", start, plen);utf8_putchar(tss.chpho[start].ch); dbg("\n");
#endif
if (tsin_is_gtab)
extract_gtab_key(start, plen, ppp);
else {
extract_pho(start, plen, (phokey_t *)ppp);
if (c_pinyin_set)
mask_tone(pp, plen, c_pinyin_set + start);
}
#if DBG
for(i=0; i < plen; i++) {
prph(pp[i]); dbg("%d", c_pinyin_set[i+start]);
}
dbg("\n");
#endif
char *pinyin_set = c_pinyin_set ? c_pinyin_set+start:NULL;
if (!tsin_seek(ppp, plen, &sti, &edi, pinyin_set)) {
// dbg("tsin_seek not found...\n");
if (plen > 1)
break;
goto next;
}
phokey_t mtk[MAX_PHRASE_LEN];
u_int mtk32[MAX_PHRASE_LEN];
u_int64_t mtk64[MAX_PHRASE_LEN];
void *pho;
if (ph_key_sz==2)
pho=mtk;
else if (ph_key_sz==4)
pho=mtk32;
else
pho=mtk64;
for (;sti < edi; sti++) {
char mtch[MAX_PHRASE_LEN*CH_SZ+1];
char match_len;
usecount_t usecount;
load_tsin_entry(sti, &match_len, &usecount, pho, (u_char *)mtch);
if (match_len < plen)
continue;
if (tsin_is_gtab) {
if (check_gtab_fixed_mismatch(start, mtch, plen))
continue;
} else
if (check_fixed_mismatch(start, mtch, plen))
continue;
if (usecount < 0)
usecount = 0;
int i;
if (ph_key_sz==2) {
if (c_pinyin_set) {
// mask_tone(pp, plen, c_pinyin_set + start);
mask_tone(mtk, plen, c_pinyin_set + start);
}
for(i=0;i < plen;i++)
if (mtk[i]!=pp[i])
break;
} else if (ph_key_sz==4) {
for(i=0;i < plen;i++)
if (mtk32[i]!=pp32[i])
break;
} else {
for(i=0;i < plen;i++)
if (mtk64[i]!=pp64[i])
break;
}
if (i < plen)
continue;
if (match_len > plen) {
continue;
}
if (usecount <= maxusecount)
continue;
pbest[0].len = plen;
maxusecount = usecount;
utf8cpyN((char *)pbest[0].str, mtch, plen);
pbest[0].flag |= FLAG_TSIN_PARSE_PHRASE;
match_phr_N = 1;
no_match_ch_N = 0;
#if DBG
utf8_putcharn(mtch, plen);
dbg(" plen %d usecount:%d ", plen, usecount);
utf8_putcharn(mtch, plen);
dbg("\n");
#endif
}
next:
#if 0
if (!match_phr_N) {
if (tsin_is_gtab) {
if (!(gbuf[start].ch[0] & 0x80))
no_match_ch_N = 0;
} else
if (!(tss.chpho[start].ch[0] & 0x80))
no_match_ch_N = 0;
}
#else
// dbg("no_match_ch_N %d\n", no_match_ch_N);
#endif
remlen = tsin_parse_len - (start + plen);
if (remlen) {
int next = start + plen;
CACHE *pca;
short smatch_phr_N, sno_match_ch_N;
int uc;
if ((pca = cache_lookup(next))) {
uc = pca->usecount;
smatch_phr_N = pca->match_phr_N;
sno_match_ch_N = pca->no_match_ch_N;
memcpy(&pbest[1], pca->best, (tsin_parse_len - next) * sizeof(TSIN_PARSE));
} else {
uc = tsin_parse_recur(next, &pbest[1], &smatch_phr_N, &sno_match_ch_N);
// dbg(" gg %d\n", smatch_phr_N);
add_cache(next, uc, &pbest[1], smatch_phr_N, sno_match_ch_N, tsin_parse_len);
}
match_phr_N += smatch_phr_N;
no_match_ch_N += sno_match_ch_N;
maxusecount += uc;
}
double score = log((double)maxusecount + MAXV) /
(pow((double)match_phr_N, 10)+ 1.0E-6) / (pow((double)no_match_ch_N, 20) + 1.0E-6);
#if DBG
dbg("st:%d plen:%d zz muse:%d ma:%d noma:%d score:%.4e %.4e\n", start, plen,
maxusecount, match_phr_N, no_match_ch_N, score, bestscore);
#endif
if (score > bestscore) {
#if DBG
dbg("is best org %.4e\n", bestscore);
#endif
bestscore = score;
memcpy(out, pbest, sizeof(TSIN_PARSE) * (tsin_parse_len - start));
#if DBG
dbg(" str:%d ", start);
int i;
for(i=0; i < tsin_parse_len - start; i++) {
utf8_putcharn((char *)out[i].str, out[i].len);
}
dbg("\n");
#endif
bestusecount = maxusecount;
*r_match_phr_N = match_phr_N;
*r_no_match_ch_N = no_match_ch_N;
}
}
if (bestusecount < 0)
bestusecount = 0;
return bestusecount;
}
void tsin_parse()
{
TSIN_PARSE out[MAX_PH_BF_EXT+1];
bzero(out, sizeof(out));
int i, ofsi;
if (tss.c_len <= 1)
return;
load_tsin_db();
set_tsin_parse_len(tss.c_len);
init_cache(tss.c_len);
char pinyin_set[MAX_PH_BF_EXT];
c_pinyin_set = pin_juyin?pinyin_set:NULL;
get_chpho_pinyin_set(pinyin_set);
short smatch_phr_N, sno_match_ch_N;
tsin_parse_recur(0, out, &smatch_phr_N, &sno_match_ch_N);
#if 0
puts("vvvvvvvvvvvvvvvv");
for(i=0; i < tss.c_len; i++) {
printf("%d:", out[i].len);
utf8_putcharn(out[i].str, out[i].len);
}
dbg("\n");
#endif
for(i=0; i < tss.c_len; i++)
tss.chpho[i].flag &= ~(FLAG_CHPHO_PHRASE_HEAD|FLAG_CHPHO_PHRASE_BODY);
for(ofsi=i=0; out[i].len; i++) {
int j, ofsj;
int psta = ofsi;
if (out[i].flag & FLAG_TSIN_PARSE_PHRASE)
tss.chpho[ofsi].flag |= FLAG_CHPHO_PHRASE_HEAD;
for(ofsj=j=0; j < out[i].len; j++) {
ofsj += utf8cpy(tss.chpho[ofsi].cha, (char *)&out[i].str[ofsj]);
// tss.chpho[ofsi].ch = tss.chpho[ofsi].cha;
tss.chpho[ofsi].flag |= FLAG_CHPHO_PHRASE_BODY;
if (out[i].flag & FLAG_TSIN_PARSE_PHRASE)
tss.chpho[ofsi].psta = psta;
ofsi++;
}
}
int ph_sta_idx = tss.ph_sta;
if (tss.chpho[tss.c_len-1].psta>=0 && tss.c_len - tss.chpho[tss.c_len-1].psta > 1) {
ph_sta_idx = tss.chpho[tss.c_len-1].psta;
}
#if 1
disp_ph_sta_idx(ph_sta_idx);
#endif
#if 0
for(i=0;i<tss.c_len;i++)
utf8_putchar(tss.chpho[i].ch);
puts("");
#endif
free_cache();
}
gboolean feedkey_gtab(KeySym key, int kbstate)
{
int i,j=0;
int inkey=0;
char *pselkey= NULL;
gboolean phrase_selected = FALSE;
char seltab_phrase[MAX_SELKEY];
gboolean is_keypad = FALSE;
gboolean shift_m = (kbstate & ShiftMask) > 0;
// gboolean ctrl_m = (kbstate & ControlMask) > 0;
gboolean capslock_on = (kbstate & LockMask);
bzero(seltab_phrase, sizeof(seltab_phrase));
// dbg("uuuuu %x %x shift,ctrl:%d,%d\n", key, kbstate, shift_m, ctrl_m);
if (!cur_inmd)
return 0;
gboolean is_dayi = !strncmp(cur_inmd->filename, "dayi", 4);
if ((tsin_chinese_english_toggle_key == TSIN_CHINESE_ENGLISH_TOGGLE_KEY_CapsLock) &&
(key == XK_Caps_Lock)){
// The CapLock status may be incorrect when XK_Caps_Lock is pressed.
gboolean new_tsin_pho_mode = ! gdk_keymap_get_caps_lock_state(gdk_keymap_get_default());
if (current_CS->tsin_pho_mode != new_tsin_pho_mode) {
current_CS->tsin_pho_mode = new_tsin_pho_mode;
save_CS_current_to_temp();
tsin_set_eng_ch(new_tsin_pho_mode);
}
}
if ((kbstate & (Mod1Mask|Mod4Mask|Mod5Mask|ControlMask))==ControlMask
&& key>='1' && key<='9' && ggg.gbufN) {
save_gtab_buf_phrase(key);
return 1;
}
if (ggg.gbufN && key==XK_Tab)
return 1;
if ((key==XK_Shift_L||key==XK_Shift_R) && !key_press_time) {
key_press_time = current_time();
key_press_time_ctrl = 0;
} else
if ((key==XK_Control_L||key==XK_Control_R) && !key_press_time_ctrl && tss.pre_selN) {
key_press_time_ctrl = current_time();
return TRUE;
} else {
key_press_time_ctrl = 0;
key_press_time = 0;
}
if (kbstate & (Mod1Mask|Mod4Mask|Mod5Mask|ControlMask)) {
return 0;
}
if (poo.same_pho_query_state == SAME_PHO_QUERY_pho_select)
return feedkey_pho(key, 0);
if (poo.same_pho_query_state == SAME_PHO_QUERY_none && gwin_pho &&
GTK_WIDGET_VISIBLE(gwin_pho))
hide_win_pho();
if (!tsin_pho_mode()) {
if (key < 0x20 || key>=0x7f)
goto shift_proc;
if (capslock_on && hime_capslock_lower)
case_inverse((KeySym *)&key, shift_m);
if (ggg.gbufN)
insert_gbuf_cursor_char(key);
else
send_ascii(key);
return 1;
}
int lcase;
lcase = tolower(key);
int ucase;
ucase = toupper(key);
if (key < 127 && cur_inmd->keymap[key]) {
if (key < 'A' || key > 'z' || (key > 'Z' && key < 'a') )
goto shift_proc;
if (cur_inmd->keymap[lcase] != cur_inmd->keymap[ucase])
goto next;
}
shift_proc:
if (shift_m && !strchr(cur_inmd->selkey, key) && !ggg.more_pg && key>=' ' && key < 0x7e &&
key!='*' && (key!='?' || (gtab_shift_phrase_key && !ggg.ci))) {
if (gtab_shift_phrase_key) {
if (tss.pre_selN && shift_char_proc(key, kbstate))
return TRUE;
if (feed_phrase(key, kbstate))
return TRUE;
} else {
if (!cur_inmd->keymap[key] || (lcase != ucase &&
cur_inmd->keymap[lcase]==cur_inmd->keymap[ucase]))
return shift_char_proc(key, kbstate);
}
}
gboolean has_wild;
has_wild = FALSE;
switch (key) {
case XK_BackSpace:
ggg.last_idx=0;
ggg.spc_pressed=0;
ggg.sel1st_i=MAX_SELKEY-1;
clear_gtab_input_error_color();
hide_gtab_pre_sel();
if (ggg.ci==0) {
if (AUTO_SELECT_BY_PHRASE)
return gtab_buf_backspace();
else
return 0;
}
if (ggg.ci>0)
ggg.inch[--ggg.ci]=0;
if (has_wild_card()) {
proc_wild_disp();
return 1;
}
ggg.wild_mode=0;
ggg.invalid_spc = FALSE;
if (ggg.ci==1 && cur_inmd->use_quick) {
int i;
clr_seltab();
for(i=0;i<cur_inmd->M_DUP_SEL;i++)
utf8cpy(seltab[i], (char *)cur_inmd->qkeys->quick1[ggg.inch[0]-1][i]);
ggg.defselN=cur_inmd->M_DUP_SEL;
DispInArea();
goto Disp_opt;
} else
if (ggg.ci==2 && cur_inmd->use_quick) {
int i;
clr_seltab();
for(i=0;i<cur_inmd->M_DUP_SEL;i++)
utf8cpy(seltab[i], (char *)cur_inmd->qkeys->quick2[ggg.inch[0]-1][ggg.inch[1]-1][i]);
ggg.defselN=cur_inmd->M_DUP_SEL;
DispInArea();
goto Disp_opt;
}
break;
case XK_KP_Enter:
case XK_Return:
if (AUTO_SELECT_BY_PHRASE) {
hide_gtab_pre_sel();
if (shift_m) {
return save_gtab_buf_shift_enter();
} else
return output_gbuf();
}
else
return 0;
case XK_Up:
if (gtab_has_input())
return TRUE;
return FALSE;
case XK_Down:
case XK_KP_Down:
if (AUTO_SELECT_BY_PHRASE)
return show_buf_select();
else
return 0;
case XK_Escape:
hide_gtab_pre_sel();
if (ggg.gtab_buf_select) {
ggg.gtab_buf_select = 0;
reset_gtab_all();
ClrSelArea();
if (hime_pop_up_win && !gtab_has_input())
hide_win_gtab();
return 1;
}
ClrSelArea();
close_gtab_pho_win();
if (ggg.ci) {
reset_gtab_all();
return 1;
} else {
if (ggg.gbufN) {
set_gtab_user_head();
return 1;
}
ClrIn();
return 0;
}
case XK_Prior:
case XK_KP_Prior:
case XK_KP_Subtract:
if (ggg.wild_mode) {
if (ggg.wild_page >= cur_inmd->M_DUP_SEL) ggg.wild_page-=cur_inmd->M_DUP_SEL;
wildcard();
return 1;
} else
if (ggg.more_pg) {
if (ggg.gtab_buf_select) {
gbuf_prev_pg();
return 1;
}
ggg.pg_idx -= page_len();
if (ggg.pg_idx < ggg.S1)
ggg.pg_idx = ggg.S1;
goto next_pg;
}
if (key==XK_KP_Subtract)
goto keypad_proc;
return win_sym_page_up();
case XK_Next:
case XK_KP_Next:
case XK_KP_Add:
if (ggg.more_pg) {
if (ggg.gtab_buf_select) {
gbuf_next_pg();
return 1;
}
next_page:
// dbg("more...\n");
ggg.pg_idx += page_len();
if (ggg.pg_idx >=ggg.E1)
ggg.pg_idx = ggg.S1;
goto next_pg;
} else {
if (key==XK_KP_Add)
goto keypad_proc;
if (win_sym_page_down())
return TRUE;
if (!ggg.gtab_buf_select && ggg.gbufN && AUTO_SELECT_BY_PHRASE)
return show_buf_select();
return FALSE;
}
case ' ':
hide_gtab_pre_sel();
if (ggg.invalid_spc && gtab_invalid_key_in)
ClrIn();
if (!gtab_invalid_key_in && ggg.spc_pressed && ggg.invalid_spc) {
ClrIn();
return 1;
}
has_wild = has_wild_card();
// dbg("ggg.wild_mode:%d ggg.more_pg:%d ggg.ci:%d has_wild:%d\n", ggg.wild_mode, ggg.more_pg, ggg.ci, has_wild);
if (ggg.wild_mode) {
// request from tetralet
if (!ggg.wild_page && ggg.total_matchN < cur_inmd->M_DUP_SEL) {
ggg.sel1st_i = 0;
goto direct_select;
}
ggg.wild_page += cur_inmd->M_DUP_SEL;
if (ggg.wild_page >= ggg.total_matchN)
ggg.wild_page=0;
wildcard();
ggg.spc_pressed = TRUE;
return 1;
} else
if (ggg.more_pg && !(_gtab_space_auto_first & GTAB_space_auto_first_any)) {
if (ggg.gtab_buf_select) {
gbuf_next_pg();
return 1;
}
else
goto next_page;
} else
if (ggg.ci==0) {
if (current_CS->b_half_full_char)
return full_char_proc(key);
if (ggg.gbufN) {
output_gbuf();
} else
return 0;
} else
if (!has_wild) {
// dbg("iii %d ggg.defselN:%d %d\n", ggg.sel1st_i, ggg.defselN, cur_inmd->M_DUP_SEL);
if (_gtab_space_auto_first == GTAB_space_auto_first_any && seltab[0][0] &&
ggg.sel1st_i==MAX_SELKEY-1) {
ggg.sel1st_i = 0;
}
if (_gtab_space_auto_first == GTAB_space_auto_first_nofull && ggg.exa_match > 1
&& !AUTO_SELECT_BY_PHRASE && gtab_dup_select_bell)
bell();
if (seltab[ggg.sel1st_i][0]) {
// dbg("ggg.last_full %d %d\n", ggg.last_full,ggg.spc_pressed);
if (gtab_full_space_auto_first || ggg.spc_pressed) {
direct_select:
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input) {
// dbg("ins ggg.kval %x\n", ggg.kval);
insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
}
else
putstr_inp(seltab[ggg.sel1st_i]); /* select 1st */
return 1;
}
}
}
ggg.last_full=0;
ggg.spc_pressed=1;
// dbg("spc_pressed=1\n");
if (has_wild) {
ggg.wild_page=0;
ggg.wild_mode=1;
wildcard();
return 1;
}
break;
case '?':
case '*':
if ((!gtab_que_wild_card && key == '?') || (!gtab_que_wild_card_asterisk && key == '*')) {
inkey=cur_inmd->keymap[key];
if ((inkey && (inkey!=cur_inmd->WILD_QUES && inkey!=cur_inmd->WILD_STAR)) || ptr_selkey(key))
goto next;
if (AUTO_SELECT_BY_PHRASE && ggg.gbufN) {
insert_gbuf_cursor_char(key);
return 1;
} else {
if (current_CS->b_half_full_char)
return full_char_proc(key);
else
return 0;
}
}
if (tss.pre_selN && shift_char_proc(key, kbstate))
return TRUE;
if (current_CS->b_half_full_char)
return full_char_proc(key);
inkey=cur_inmd->keymap[key];
if ((inkey && (inkey!=cur_inmd->WILD_STAR && inkey!=cur_inmd->WILD_QUES)) || ptr_selkey(key)) {
// dbg("%d %d\n", inkey, cur_inmd->WILD_STAR);
goto next;
}
if (ggg.ci< cur_inmd->MaxPress) {
ggg.inch[ggg.ci++]=inkey;
DispInArea();
if (hime_pop_up_win)
show_win_gtab();
ggg.total_matchN = 0;
ggg.wild_page=0;
ggg.wild_mode=1;
wildcard();
return 1;
}
return 0;
case XK_Left:
case XK_KP_Left:
return gbuf_cursor_left();
case XK_Right:
case XK_KP_Right:
return gbuf_cursor_right();
case XK_Home:
case XK_KP_Home:
return gbuf_cursor_home();
case XK_End:
case XK_KP_End:
return gbuf_cursor_end();
case XK_Delete:
case XK_KP_Delete:
return gtab_buf_delete();
case XK_Shift_L:
case XK_Shift_R:
case XK_Control_R:
case XK_Control_L:
case XK_Alt_L:
case XK_Alt_R:
case XK_Caps_Lock:
return 0;
case '`':
if (gtab_pho_query && !cur_inmd->keymap[key]) {
poo.same_pho_query_state = SAME_PHO_QUERY_gtab_input;
reset_gtab_all();
disp_gtab_sel(_("輸入要查的同音字，接著在注音視窗選字"));
if (hime_pop_up_win)
show_win_gtab();
disp_pho_sel("");
init_gtab_pho_query_win();
return 1;
}
default:
next:
if (key < 0x7f)
inkey= cur_inmd->keymap[key];
else
inkey = 0;
if (shift_m && !inkey && !tss.ctrl_pre_sel &&
tss.pre_selN && shift_char_proc(key, kbstate))
return TRUE;
clear_gtab_input_error_color();
if (ggg.invalid_spc && gtab_invalid_key_in) {
ClrIn();
}
if (key>=XK_KP_0 && key<=XK_KP_9) {
if (!ggg.ci) {
if (ggg.gbufN) {
insert_gbuf_cursor_char(key - XK_KP_0 + '0');
return 1;
} else
return 0;
}
if (is_dayi) {
key = key - XK_KP_0 + '0';
is_keypad = TRUE;
}
}
int keypad;
keypad_proc:
keypad = keypad_proc(key);
if (keypad) {
if (!ggg.ci) {
if (ggg.gbufN) {
insert_gbuf_cursor_char(keypad);
return 1;
} else
return 0;
}
}
char *pendkey = strchr(cur_inmd->endkey, key);
pselkey=ptr_selkey(key);
if (!pselkey && (key < 32 || key > 0x7e) && (gtab_full_space_auto_first || ggg.spc_pressed)) {
// dbg("%x %x ggg.sel1st_i:%d '%c'\n", pselkey, key, ggg.sel1st_i, seltab[ggg.sel1st_i][0]);
if (seltab[ggg.sel1st_i][0]) {
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
else
putstr_inp(seltab[ggg.sel1st_i]); /* select 1st */
}
return 0;
}
// dbg("ggg.spc_pressed %d %d %d is_keypad:%d\n", ggg.spc_pressed, ggg.last_full, cur_inmd->MaxPress, is_keypad);
#if 1 // for dayi, testcase : 6 space keypad6
int vv = pselkey - cur_inmd->selkey;
if (pselkey && tss.pre_selN && !ggg.gtab_buf_select && (tss.ctrl_pre_sel||
((!inkey||ggg.spc_pressed||is_keypad)&&! gtab_disp_partial_match_on() && !gtab_pre_select_on()))) {
if (gtab_pre_select_idx(vv))
return TRUE;
} else
if (( (ggg.spc_pressed||ggg.last_full||is_keypad) ||(ggg.wild_mode && (!inkey ||pendkey)) || ggg.gtab_buf_select) && pselkey) {
if ((_gtab_space_auto_first & GTAB_space_auto_first_any) && !ggg.wild_mode)
vv++;
if (vv<0)
vv=9;
if (seltab[vv][0]) {
if (AUTO_SELECT_BY_PHRASE && !same_query_show_pho_win()) {
if (ggg.gtab_buf_select && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
set_gbuf_c_sel(vv);
else
insert_gbuf_cursor1_cond(seltab[vv], ggg.kval, ggg.exa_match);
}
else {
putstr_inp(seltab[vv]);
}
if (hime_pop_up_win && !gtab_has_input())
hide_win_gtab();
return 1;
}
}
#endif
// dbg("iii %x sel1st_i:%d auto:%d\n", pselkey, ggg.sel1st_i, AUTO_SELECT_BY_PHRASE);
if (seltab[ggg.sel1st_i][0] && !ggg.wild_mode &&
(gtab_full_space_auto_first||ggg.spc_pressed||ggg.last_full) ) {
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
else
putstr_inp(seltab[ggg.sel1st_i]); /* select 1st */
}
#if 0
if (key > 0x7f) {
return 0;
}
#endif
ggg.spc_pressed=0;
// for cj & boshiamy to input digits
if (!ggg.ci && !inkey) {
if (current_CS->b_half_full_char)
return full_char_proc(key);
else {
if (ggg.gbufN && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input) {
insert_gbuf_cursor_char(key);
return 1;
}
else
return 0;
}
}
if (ggg.wild_mode && inkey>=1 && ggg.ci< cur_inmd->MaxPress) {
ggg.inch[ggg.ci++]=inkey;
if (hime_pop_up_win)
show_win_gtab();
proc_wild_disp();
return 1;
}
if (inkey>=1 && ggg.ci< cur_inmd->MaxPress) {
ggg.inch[ggg.ci++]=inkey;
hide_gtab_pre_sel();
if (hime_pop_up_win)
show_win_gtab();
ggg.last_full=0;
if (cur_inmd->use_quick && !pendkey) {
if (ggg.ci==1) {
int i;
for(i=0;i < cur_inmd->M_DUP_SEL; i++) {
utf8cpy(seltab[i], (char *)&cur_inmd->qkeys->quick1[inkey-1][i]);
}
ggg.defselN=cur_inmd->M_DUP_SEL;
DispInArea();
goto Disp_opt;
} else
if (ggg.ci==2 && !pselkey) {
int i;
for(i=0;i < cur_inmd->M_DUP_SEL; i++) {
utf8cpy(seltab[i], (char *)&cur_inmd->qkeys->quick2[ggg.inch[0]-1][inkey-1][i]);
}
ggg.defselN=cur_inmd->M_DUP_SEL;
DispInArea();
goto Disp_opt;
}
}
} else
if (ggg.ci == cur_inmd->MaxPress && !pselkey) {
bell();
return 1;
}
if (inkey) {
for(i=0; i < MAX_TAB_KEY_NUM64_6; i++)
if (ggg.inch[i]>=cur_inmd->WILD_QUES) {
DispInArea();
if (ggg.ci==cur_inmd->MaxPress) {
ggg.wild_mode=1;
ggg.wild_page=0;
wildcard();
}
return 1;
}
} else {
if (!pselkey) {
if (current_CS->b_half_full_char)
return full_char_proc(key);
else {
if (key>=' ' && key<0x7f && AUTO_SELECT_BY_PHRASE && ggg.gbufN)
insert_gbuf_cursor_char(key);
else
return 0;
}
}
if (ggg.defselN) {
goto YYYY;
}
}
} /* switch */
if (ggg.ci==0) {
ClrSelArea();
ClrIn();
return 1;
}
ggg.invalid_spc = FALSE;
char *pendkey = NULL;
pendkey = strchr(cur_inmd->endkey, key);
DispInArea();
ggg.kval=0;
for(i=0; i < Max_tab_key_num; i++) {
ggg.kval|= (u_int64_t)ggg.inch[i] << (KeyBits * (Max_tab_key_num - 1 - i));
}
#if 1
if (ggg.last_idx)
ggg.S1=ggg.last_idx;
else
#endif
ggg.S1=cur_inmd->idx1[ggg.inch[0]];
// dbg("--------- ch:%d %d val %llx ggg.S1:%d\n", ggg.inch[0], Max_tab_key_num, ggg.kval, ggg.S1);
int oE1;
oE1=cur_inmd->idx1[ggg.inch[0]+1];
if (cur_inmd->keybits==6)
vmaskci = cur_inmd->key64 ? vmask64[ggg.ci]:vmask[ggg.ci];
else
vmaskci = cur_inmd->key64 ? vmask64_7[ggg.ci]:vmask_7[ggg.ci];
gtab_scan_pre_select(TRUE);
while ((CONVT2(cur_inmd, ggg.S1) & vmaskci) != ggg.kval &&
CONVT2(cur_inmd, ggg.S1) < ggg.kval && ggg.S1<oE1)
ggg.S1++;
ggg.pg_idx=ggg.last_idx=ggg.S1;
#if 0
dbg("MaxPress:%d vmaskci:%llx kval:%llx ggg.ci:%d !=%d S1:%d kval:%x\n", cur_inmd->MaxPress,
vmaskci, ggg.kval, ggg.ci,
((CONVT2(cur_inmd, ggg.S1) & vmaskci)!=ggg.kval), ggg.S1);
#endif
if ((CONVT2(cur_inmd, ggg.S1) & vmaskci)!=ggg.kval || (ggg.wild_mode && ggg.defselN) ||
((/* ggg.ci==cur_inmd->MaxPress|| */ ggg.spc_pressed) && ggg.defselN &&
(pselkey && ( pendkey || ggg.spc_pressed)) ) ) {
YYYY:
if ((pselkey || ggg.wild_mode) && ggg.defselN) {
int vv = pselkey - cur_inmd->selkey;
if ((_gtab_space_auto_first & GTAB_space_auto_first_any) && !ggg.wild_mode
&& ggg.exa_match && (!cur_inmd->use_quick || ggg.ci!=2))
vv++;
if (vv<0)
vv=9;
if (seltab[vv][0]) {
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
insert_gbuf_cursor1_cond(seltab[vv], ggg.kval, ggg.exa_match);
else
putstr_inp(seltab[vv]);
return 1;
}
}
if (pselkey && !ggg.defselN)
return 0;
if (gtab_invalid_key_in) {
if (ggg.spc_pressed) {
bell_err();
ggg.invalid_spc = TRUE;
// dbg("ggg.invalid_spc\n");
} else {
seltab[0][0]=0;
ClrSelArea();
}
} else {
if (gtab_dup_select_bell)
bell();
if (ggg.ci>0)
ggg.inch[--ggg.ci]=0;
}
ggg.last_idx=0;
DispInArea();
return 1;
}
//refill:
j=ggg.S1;
while(CONVT2(cur_inmd, j)==ggg.kval && j<oE1)
j++;
ggg.E1 = j;
ggg.total_matchN = ggg.E1 - ggg.S1;
ggg.pg_idx = ggg.S1;
ggg.more_pg = 0;
if (ggg.total_matchN > page_len()) {
if ((_gtab_space_auto_first & GTAB_space_auto_first_any) || ggg.spc_pressed || pendkey ||
(ggg.ci==cur_inmd->MaxPress && (_gtab_space_auto_first & GTAB_space_auto_first_full)))
ggg.more_pg = 1;
}
if (ggg.ci < cur_inmd->MaxPress && !ggg.spc_pressed && !pendkey && !ggg.more_pg) {
j = ggg.S1;
ggg.exa_match=0;
clr_seltab();
int match_cnt=0;
while (CONVT2(cur_inmd, j)==ggg.kval && ggg.exa_match <= page_len()) {
seltab_phrase[ggg.exa_match] = load_seltab(j, ggg.exa_match);
match_cnt++;
ggg.exa_match++;
j++;
}
ggg.defselN=ggg.exa_match;
// dbg("--- ggg.exa_match %d\n", ggg.exa_match);
if (ggg.defselN > page_len())
ggg.defselN--;
int shiftb=(KEY_N - 1 -ggg.ci) * KeyBits;
// if (gtab_disp_partial_match_on)
while((CONVT2(cur_inmd, j) & vmaskci)==ggg.kval && j<oE1) {
int fff=cur_inmd->keycol[(CONVT2(cur_inmd, j)>>shiftb) & cur_inmd->kmask];
u_char *tbl_ch = tblch(j);
if (gtab_disp_partial_match_on() && (!seltab[fff][0] || seltab_phrase[fff] ||
(bchcmp(seltab[fff], tbl_ch)>0 && fff > ggg.exa_match))) {
seltab_phrase[fff] = load_seltab(j, fff);
ggg.defselN++;
}
match_cnt++;
#if 0
dbg("jj %d", fff); utf8_putchar(seltab[fff]); dbg("\n");
#endif
j++;
}
if (gtab_unique_auto_send_on()) {
char *first_str=NULL;
for(i=0; i < page_len(); i++) {
if (!seltab[i][0])
continue;
if (!first_str)
first_str = seltab[i];
}
if (match_cnt==1 && first_str) {
if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
insert_gbuf_nokey(first_str);
else
putstr_inp(first_str);
return 1;
}
}
} else {
void disp_selection0(gboolean phrase_selected, gboolean force_disp)
{
char pgstr[32];
pgstr[0]=0;
page_no_str(pgstr);
if (!gtab_vertical_select_on()) {
if (ggg.more_pg)
set_page_label(pgstr);
else
clear_page_label();
}
char tt[1024];
tt[0]=0;
char uu[MAX_CIN_PHR];
int ofs;
if (!ggg.wild_mode && ggg.exa_match && (_gtab_space_auto_first & GTAB_space_auto_first_any)) {
strcat(tt, htmlspecialchars(seltab[0], uu));
if (gtab_vertical_select_on())
strcat(tt, "\n");
else
strcat(tt, " ");
ofs = 1;
} else {
ofs = 0;
}
int i,max_i;
for(max_i = cur_inmd->M_DUP_SEL + ofs-1; max_i>=0; max_i--)
if (seltab[max_i][0])
break;
for(i=ofs; i<= max_i; i++) {
if (seltab[i][0]) {
char selback[MAX_CIN_PHR+16];
htmlspecialchars(seltab[i], selback);
utf8cpy(uu, &cur_inmd->selkey[i - ofs]);
char vvv[16];
char www[1024];
if (hime_win_color_use)
sprintf(www, "<span foreground=\"%s\">%s</span>", hime_sel_key_color, htmlspecialchars(uu, vvv));
else
sprintf(www, "<span foreground=\""HIME_SEL_KEY_COLOR_DEFAULT"\">%s</span>", htmlspecialchars(uu, vvv));
strcat(tt, www);
if (gtab_vertical_select_on())
strcat(tt, " ");
if (phrase_selected && i==ggg.sel1st_i) {
strcat(tt, "<span foreground=\"red\">");
strcat(strcat(tt, selback), " ");
strcat(tt, "</span>");
} else {
char uu[MAX_CIN_PHR];
if (gtab_vertical_select_on()) {
utf8cpy_bytes(uu, selback, 120);
strcat(tt, uu);
} else {
char *p = selback;
static char *skip[]={"http://", "ftp://", "https://", NULL};
int j;
for(j=0; skip[j]; j++)
if (!strncmp(seltab[i], skip[j], strlen(skip[j]))) {
p+=strlen(skip[j]);
break;
}
utf8cpy_bytes(uu, p, 6 * 3);
strcat(strcat(tt, uu), " ");
}
}
if (gtab_vertical_select_on())
strcat(tt, "\n");
} else {
extern gboolean b_use_full_space;
if (!gtab_vertical_select_on() && gtab_disp_partial_match_on()) {
if (b_use_full_space)
strcat(tt, " ");
else {
strcat(tt, " ");
}
}
}
}
if (gtab_vertical_select_on() && pgstr[0]) {
char tstr2[16];
sprintf(tstr2, "(%s)", pgstr);
strcat(tt, tstr2);
}
int len = strlen(tt);
if (len && tt[len-1] == '\n')
tt[len-1] = 0;
if (gtab_pre_select_or_partial_on() || ggg.wild_mode || ggg.spc_pressed || ggg.last_full || force_disp) {
disp_gtab_sel(tt);
}
}
