← Back to branch summary

~ubuntu-branches/ubuntu/precise/hime/precise

« back to all changes in this revision

Viewing changes to src/gtab.c

  • Committer: Package Import Robot
  • Author(s): Yao Wei (魏銘廷)
  • Date: 2012-01-14 00:24:08 UTC
  • Revision ID: package-import@ubuntu.com-20120114002408-e79gagbeg1rt8npv
Tags: upstream-0.9.9
Import upstream version 0.9.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gtab.c
 
1
/* Copyright (C) 2004-2011 Edward Der-Hua Liu, Hsin-Chu, Taiwan
 
2
 *
 
3
 * This library is free software; you can redistribute it and/or
 
4
 * modify it under the terms of the GNU Lesser General Public
 
5
 * License as published by the Free Software Foundation; either
 
6
 * version 2.1 of the License, or (at your option) any later version.
 
7
 *
 
8
 * This library is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
11
 * Lesser General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU Lesser General Public
 
14
 * License along with this library; if not, write to the Free Software
 
15
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
16
 */
 
17
 
 
18
#include <sys/stat.h>
 
19
#include <regex.h>
 
20
#include "hime.h"
 
21
#include "gtab.h"
 
22
#include "pho.h"
 
23
#include "hime-conf.h"
 
24
#include "hime-endian.h"
 
25
#include "gtab-buf.h"
 
26
#include "tsin.h"
 
27
#include "gst.h"
 
28
 
 
29
extern gboolean test_mode;
 
30
gboolean gtab_phrase_on();
 
31
gboolean gtab_disp_partial_match_on(), gtab_vertical_select_on(), gtab_pre_select_on(), gtab_unique_auto_send_on(), gtab_press_full_auto_send_on();
 
32
void init_seltab(char ***p);
 
33
 
 
34
extern gint64 key_press_time, key_press_time_ctrl;
 
35
 
 
36
extern GtkWidget *gwin_gtab;
 
37
void hide_gtab_pre_sel();
 
38
void gtab_scan_pre_select(gboolean);
 
39
 
 
40
extern GTAB_space_pressed_E _gtab_space_auto_first;
 
41
extern char *TableDir;
 
42
 
 
43
extern INMD *cur_inmd;
 
44
extern char **seltab;
 
45
 
 
46
extern char str_key_codes[128];
 
47
void disp_pho_sel(char *s);
 
48
 
 
49
#define gtab_full_space_auto_first (_gtab_space_auto_first & (GTAB_space_auto_first_any|GTAB_space_auto_first_full))
 
50
#define AUTO_SELECT_BY_PHRASE (gtab_phrase_on())
 
51
 
 
52
gboolean use_tsin_sel_win()
 
53
{
 
54
  return  gtab_vertical_select_on() && gtab_phrase_pre_select;
 
55
}
 
56
 
 
57
 
 
58
static gboolean gtab_pre_select_or_partial_on()
 
59
{
 
60
  return gtab_pre_select_on() || (cur_inmd->flag&FLAG_GTAB_DISP_PARTIAL_MATCH)!=0;
 
61
}
 
62
 
 
63
gboolean same_query_show_pho_win()
 
64
{
 
65
  return poo.same_pho_query_state != SAME_PHO_QUERY_none;
 
66
}
 
67
 
 
68
gboolean hime_edit_display_ap_only();
 
69
gboolean gtab_has_input()
 
70
{
 
71
  int i;
 
72
 
 
73
  for(i=0; i < MAX_TAB_KEY_NUM64_6; i++)
 
74
    if (ggg.inch[i])
 
75
      return TRUE;
 
76
 
 
77
  if (same_query_show_pho_win())
 
78
    return TRUE;
 
79
 
 
80
  if (ggg.gtab_buf_select)
 
81
    return TRUE;
 
82
 
 
83
  if (ggg.gbufN && !hime_edit_display_ap_only())
 
84
    return TRUE;
 
85
 
 
86
  return FALSE;
 
87
}
 
88
 
 
89
#define tblch(i) tblch2(cur_inmd, i)
 
90
 
 
91
int load_phr_ch(INMD *inm, u_char *ch, char *tt)
 
92
{
 
93
  int phrno =((int)(ch[0])<<16)|((int)ch[1]<<8)|ch[2];
 
94
  int ofs = inm->phridx[phrno], ofs1 = inm->phridx[phrno+1];
 
95
 
 
96
//  dbg("load_phr   j:%d %d %d %d\n", j, phrno, ofs, ofs1);
 
97
  int len = ofs1 - ofs;
 
98
 
 
99
  if (len > MAX_CIN_PHR || len <= 0) {
 
100
    dbg("phrae error %d\n", len);
 
101
    strcpy(tt,"err");
 
102
    return 0;
 
103
  }
 
104
 
 
105
  memcpy(tt, inm->phrbuf + ofs, len);
 
106
  tt[len]=0;
 
107
  return len;
 
108
}
 
109
 
 
110
static void load_phr(int j, char *tt)
 
111
{
 
112
  u_char *ch = tblch(j);
 
113
 
 
114
  load_phr_ch(cur_inmd, ch, tt);
 
115
}
 
116
 
 
117
static int qcmp_strlen(const void *aa, const void *bb)
 
118
{
 
119
  char *a = *((char **)aa), *b = *((char **)bb);
 
120
 
 
121
  return strlen(a) - strlen(b);
 
122
}
 
123
 
 
124
void set_key_codes_label(char *s, int better);
 
125
void set_page_label(char *s);
 
126
 
 
127
static void clear_page_label()
 
128
{
 
129
  set_page_label("");
 
130
}
 
131
 
 
132
int gtab_key2name(INMD *tinmd, u_int64_t key, char *t, int *rtlen);
 
133
 
 
134
 
 
135
int ch_to_gtab_keys(INMD *tinmd, char *ch, u_int64_t keys[])
 
136
{
 
137
  int n = utf8_str_N(ch);
 
138
  gboolean phrase = n > 1 || !(ch[0] & 0x80);
 
139
  int i, keysN=0;
 
140
  for(i=0; i < tinmd->DefChars; i++) {
 
141
    char *chi = (char *)tblch2(tinmd, i);
 
142
 
 
143
    if (phrase) {
 
144
      if ((chi[0] & 0x80))
 
145
        continue;
 
146
      char tstr[512];
 
147
      load_phr_ch(tinmd, (u_char *)chi, tstr);
 
148
      if (strcmp(tstr, ch))
 
149
        continue;
 
150
    } else {
 
151
      if (!(chi[0] & 0x80))
 
152
        continue;
 
153
      if (!utf8_eq(chi, ch))
 
154
        continue;
 
155
    }
 
156
 
 
157
    u_int64_t key = CONVT2(tinmd, i);
 
158
    keys[keysN++] = key;
 
159
  }
 
160
  return keysN;
 
161
}
 
162
 
 
163
void lookup_gtabn(char *ch, char *out)
 
164
{
 
165
  char outbuf[512];
 
166
  char *tbuf[128];
 
167
  int tbufN=0;
 
168
  INMD *tinmd = &inmd[default_input_method];
 
169
 
 
170
  if (!tinmd->DefChars)
 
171
    tinmd = cur_inmd;
 
172
 
 
173
  if (!tinmd)
 
174
    return;
 
175
 
 
176
  gboolean need_disp = FALSE;
 
177
 
 
178
  if (!out) {
 
179
    out = outbuf;
 
180
    need_disp = TRUE;
 
181
  }
 
182
 
 
183
  out[0]=0;
 
184
 
 
185
 
 
186
  int min_klen = 100;
 
187
  u_int64_t keys[64];
 
188
  int keysN = ch_to_gtab_keys(tinmd, ch, keys);
 
189
 
 
190
  int i;
 
191
  for(i=0; i < keysN; i++) {
 
192
    int tlen, klen;
 
193
    char t[CH_SZ * 10 + 1];
 
194
 
 
195
    klen = gtab_key2name(tinmd, keys[i], t, &tlen);
 
196
 
 
197
    if (klen < min_klen)
 
198
      min_klen = klen;
 
199
 
 
200
    t[tlen]=0;
 
201
 
 
202
    tbuf[tbufN] = strdup(t);
 
203
    tbufN++;
 
204
  }
 
205
 
 
206
 
 
207
  qsort(tbuf, tbufN, sizeof(char *), qcmp_strlen);
 
208
  out[0]=0;
 
209
 
 
210
  for(i=0; i < tbufN; i++) {
 
211
#define MAX_DISP_MATCH 40
 
212
    if (strlen(out) < MAX_DISP_MATCH) {
 
213
      strcat(out, tbuf[i]);
 
214
      if (i < tbufN-1)
 
215
        strcat(out, " |");
 
216
    }
 
217
 
 
218
    free(tbuf[i]);
 
219
  }
 
220
 
 
221
  if (!out[0] || !need_disp)
 
222
    return;
 
223
 
 
224
 
 
225
  set_key_codes_label(out, ggg.ci > min_klen);
 
226
  void set_key_codes_label_pho(char *s);
 
227
  set_key_codes_label_pho(out);
 
228
}
 
229
 
 
230
void lookup_gtab(char *ch)
 
231
{
 
232
  char tt[CH_SZ+1];
 
233
  utf8cpy(tt, ch);
 
234
  lookup_gtabn(tt, NULL);
 
235
}
 
236
 
 
237
 
 
238
void lookup_gtab_out(char *ch, char *out)
 
239
{
 
240
  char tt[CH_SZ+1];
 
241
  utf8cpy(tt, ch);
 
242
  lookup_gtabn(tt, out);
 
243
}
 
244
 
 
245
void free_gtab()
 
246
{
 
247
  int i;
 
248
 
 
249
  for(i=0; i < inmdN; i++) {
 
250
    INMD *inp = &inmd[i];
 
251
    free(inp->tbl); inp->tbl = NULL;
 
252
    free(inp->tbl64); inp->tbl64 = NULL;
 
253
    free(inp->phridx); inp->phridx = NULL;
 
254
    free(inp->phrbuf); inp->phrbuf = NULL;
 
255
    free(inp->keyname_lookup); inp->keyname_lookup = NULL;
 
256
  }
 
257
 
 
258
  free(inmd);
 
259
}
 
260
 
 
261
 
 
262
char *b1_cat(char *s, char c)
 
263
{
 
264
  char t[2];
 
265
  t[0]=c;
 
266
  t[1]=0;
 
267
 
 
268
  return strcat(s, t);
 
269
}
 
270
 
 
271
 
 
272
char *bch_cat(char *s, char *ch)
 
273
{
 
274
  char t[CH_SZ + 1];
 
275
  int len = u8cpy(t, ch);
 
276
  t[len]=0;
 
277
 
 
278
  return strcat(s, t);
 
279
}
 
280
 
 
281
 
 
282
void minimize_win_gtab();
 
283
void disp_gtab_sel(char *s);
 
284
 
 
285
void ClrSelArea()
 
286
{
 
287
  disp_gtab_sel("");
 
288
  minimize_win_gtab();
 
289
//  hide_gtab_pre_sel();
 
290
}
 
291
 
 
292
 
 
293
void disp_gtab(char *);
 
294
void clear_gtab_input_error_color();
 
295
 
 
296
static void clr_seltab()
 
297
{
 
298
  int i;
 
299
  if (!seltab)
 
300
    return;
 
301
 
 
302
  for(i=0; i < MAX_SELKEY; i++)
 
303
     seltab[i][0]=0;
 
304
}
 
305
 
 
306
void clear_gtab_in_area(), hide_win_gtab();
 
307
void ClrIn()
 
308
{
 
309
  bzero(ggg.inch,sizeof(ggg.inch));
 
310
  clr_seltab();
 
311
  ggg.total_matchN=ggg.pg_idx=ggg.more_pg=ggg.wild_mode=ggg.wild_page=ggg.last_idx=ggg.defselN=ggg.exa_match=
 
312
  ggg.spc_pressed=ggg.ci=ggg.invalid_spc=0;
 
313
 
 
314
  ggg.sel1st_i=MAX_SELKEY-1;
 
315
 
 
316
  clear_gtab_in_area();
 
317
  ggg.last_idx = 0;
 
318
 
 
319
  if (hime_pop_up_win && !gtab_has_input() && !tss.pre_selN)
 
320
    hide_win_gtab();
 
321
 
 
322
  clear_gtab_input_error_color();
 
323
  clear_page_label();
 
324
//  hide_gtab_pre_sel();
 
325
}
 
326
 
 
327
 
 
328
void hide_win_pho();
 
329
 
 
330
void close_gtab_pho_win()
 
331
{
 
332
  if (test_mode)
 
333
    return;
 
334
  if (same_query_show_pho_win()) {
 
335
    poo.same_pho_query_state = SAME_PHO_QUERY_none;
 
336
    hide_win_pho();
 
337
    if (hime_pop_up_win && (str_key_codes[0]!='\0'))
 
338
      hide_win_gtab();
 
339
  }
 
340
}
 
341
 
 
342
void gtab_disp_empty(char *tt, int N);
 
343
extern int win_gtab_max_key_press;
 
344
 
 
345
static void DispInArea()
 
346
{
 
347
  int i;
 
348
 
 
349
//  hide_gtab_pre_sel();
 
350
 
 
351
//  dbg("sel1st:%d\n", ggg.sel1st_i);
 
352
  if (hime_display_on_the_spot_key()) {
 
353
    if (gwin_gtab && GTK_WIDGET_VISIBLE(gwin_gtab) && poo.same_pho_query_state == SAME_PHO_QUERY_none)
 
354
      hide_win_gtab();
 
355
    return;
 
356
  }
 
357
 
 
358
  char tt[128];
 
359
  int ttN=0;
 
360
 
 
361
  if (win_gtab_max_key_press < ggg.ci)
 
362
    win_gtab_max_key_press = ggg.ci;
 
363
 
 
364
  for(i=0;i<ggg.ci;i++) {
 
365
    char *p=(char *)&cur_inmd->keyname[ggg.inch[i] * CH_SZ];
 
366
    int len;
 
367
    if (*p & 0x80)
 
368
      len=utf8cpy(tt+ttN, p);
 
369
    else {
 
370
      len = strlen(p);
 
371
      strcpy(tt+ttN, p);
 
372
    }
 
373
 
 
374
    ttN+=len;
 
375
  }
 
376
 
 
377
  tt[ttN]=0;
 
378
 
 
379
  gtab_disp_empty(tt, win_gtab_max_key_press - i);
 
380
 
 
381
  disp_gtab(tt);
 
382
  minimize_win_gtab();
 
383
}
 
384
 
 
385
int get_DispInArea_str(char *out)
 
386
{
 
387
  int outN=0, i;
 
388
  for(i=0;i<ggg.ci;i++) {
 
389
    char *p = (char *)&cur_inmd->keyname[ggg.inch[i] * CH_SZ];
 
390
    if (*p & 0x80)
 
391
      outN+=u8cpy(out+outN, p);
 
392
    else {
 
393
      int len = strlen(p);
 
394
      memcpy(out+outN, p, len);
 
395
      outN+=len;
 
396
    }
 
397
  }
 
398
 
 
399
#if 0
 
400
  if (outN) {
 
401
    hide_gtab_pre_sel();
 
402
  }
 
403
#endif
 
404
 
 
405
  out[outN]=0;
 
406
//  dbg("get_DispInArea_str\n", out);
 
407
  return outN;
 
408
}
 
409
 
 
410
 
 
411
void set_gtab_input_method_name(char *s);
 
412
void case_inverse(KeySym *xkey, int shift_m);
 
413
 
 
414
extern unich_t *fullchar[];
 
415
 
 
416
void start_gtab_pho_query(char *utf8);
 
417
 
 
418
void clear_after_put()
 
419
{
 
420
  ClrIn();
 
421
  ClrSelArea();
 
422
}
 
423
 
 
424
void add_to_tsin_buf_str(char *str);
 
425
gboolean init_in_method(int in_no);
 
426
void hide_win_kbm();
 
427
 
 
428
void hide_row2_if_necessary()
 
429
{
 
430
  if ((!ggg.wild_mode && gtab_hide_row2) || !gtab_disp_key_codes) {
 
431
    set_key_codes_label(NULL, 0);
 
432
  }
 
433
}
 
434
 
 
435
static void putstr_inp(char *p)
 
436
{
 
437
  clear_page_label();
 
438
 
 
439
//  dbg("gtab_hide_row2 %d\n", gtab_hide_row2);
 
440
  hide_row2_if_necessary();
 
441
 
 
442
  char_play(p);
 
443
 
 
444
  int to_tsin = (cur_inmd->flag & FLAG_GTAB_SYM_KBM) && inmd[default_input_method].method_type==method_type_TSIN && tss.c_len;
 
445
 
 
446
  if (utf8_str_N(p) > 1  || !(p[0]&128)) {
 
447
    if ((gtab_disp_key_codes && !gtab_hide_row2) || ggg.wild_mode)
 
448
      lookup_gtabn(p, NULL);
 
449
    if (to_tsin) {
 
450
      add_to_tsin_buf_str(p);
 
451
    }
 
452
    else
 
453
      send_text(p);
 
454
  }
 
455
  else {
 
456
    if (poo.same_pho_query_state == SAME_PHO_QUERY_gtab_input) {
 
457
      poo.same_pho_query_state = SAME_PHO_QUERY_pho_select;
 
458
      start_gtab_pho_query(p);
 
459
 
 
460
      ClrIn();
 
461
      ClrSelArea();
 
462
      return;
 
463
    }
 
464
 
 
465
    if ((gtab_disp_key_codes && !gtab_hide_row2) || ggg.wild_mode)
 
466
      lookup_gtab(p);
 
467
 
 
468
    if (to_tsin)
 
469
      add_to_tsin_buf_str(p);
 
470
    else
 
471
      send_utf8_ch(p);
 
472
  }
 
473
 
 
474
  clear_after_put();
 
475
 
 
476
  if ((cur_inmd->flag & FLAG_GTAB_SYM_KBM)) {
 
477
    extern int win_kbm_inited, b_show_win_kbm;
 
478
    init_in_method(default_input_method);
 
479
    if (win_kbm_inited && !b_show_win_kbm)
 
480
      hide_win_kbm();
 
481
  }
 
482
}
 
483
 
 
484
 
 
485
#define swap(a,b) { tt=a; a=b; b=tt; }
 
486
 
 
487
static u_int vmask[]=
 
488
{ 0,
 
489
 (0x3f<<24),
 
490
 (0x3f<<24)|(0x3f<<18),
 
491
 (0x3f<<24)|(0x3f<<18)|(0x3f<<12),
 
492
 (0x3f<<24)|(0x3f<<18)|(0x3f<<12)|(0x3f<<6),
 
493
 (0x3f<<24)|(0x3f<<18)|(0x3f<<12)|(0x3f<<6)|0x3f
 
494
};
 
495
 
 
496
 
 
497
static u_int vmask_7[]=
 
498
{ 0,
 
499
 (0x7f<<21),
 
500
 (0x7f<<21)|(0x7f<<14),
 
501
 (0x7f<<21)|(0x7f<<14)|(0x7f<<7),
 
502
 (0x7f<<21)|(0x7f<<14)|(0x7f<<7)|0x7f,
 
503
};
 
504
 
 
505
#define KKK ((u_int64_t)0x3f)
 
506
 
 
507
 
 
508
static u_int64_t vmask64[]=
 
509
{ 0,
 
510
  (KKK<<54),
 
511
  (KKK<<54)|(KKK<<48),
 
512
  (KKK<<54)|(KKK<<48)|(KKK<<42),
 
513
  (KKK<<54)|(KKK<<48)|(KKK<<42)|(KKK<<36),
 
514
  (KKK<<54)|(KKK<<48)|(KKK<<42)|(KKK<<36)|(KKK<<30),
 
515
  (KKK<<54)|(KKK<<48)|(KKK<<42)|(KKK<<36)|(KKK<<30)|(KKK<<24),
 
516
  (KKK<<54)|(KKK<<48)|(KKK<<42)|(KKK<<36)|(KKK<<30)|(KKK<<24)|(KKK<<18),
 
517
  (KKK<<54)|(KKK<<48)|(KKK<<42)|(KKK<<36)|(KKK<<30)|(KKK<<24)|(KKK<<18)|(KKK<<12),
 
518
  (KKK<<54)|(KKK<<48)|(KKK<<42)|(KKK<<36)|(KKK<<30)|(KKK<<24)|(KKK<<18)|(KKK<<12)|(KKK<<6),
 
519
  (KKK<<54)|(KKK<<48)|(KKK<<42)|(KKK<<36)|(KKK<<30)|(KKK<<24)|(KKK<<18)|(KKK<<12)|(KKK<<6)|KKK
 
520
};
 
521
 
 
522
 
 
523
#define KKK7 ((u_int64_t)0x7f)
 
524
 
 
525
static u_int64_t vmask64_7[]=
 
526
{ 0,
 
527
 (KKK7<<56),
 
528
 (KKK7<<56)|(KKK7<<49),
 
529
 (KKK7<<56)|(KKK7<<49)|(KKK7<<42),
 
530
 (KKK7<<56)|(KKK7<<49)|(KKK7<<42)|(KKK7<<35),
 
531
 (KKK7<<56)|(KKK7<<49)|(KKK7<<42)|(KKK7<<35)|(KKK7<<28),
 
532
 (KKK7<<56)|(KKK7<<49)|(KKK7<<42)|(KKK7<<35)|(KKK7<<28)|(KKK7<<21),
 
533
 (KKK7<<56)|(KKK7<<49)|(KKK7<<42)|(KKK7<<35)|(KKK7<<28)|(KKK7<<21)|(KKK7<<14),
 
534
 (KKK7<<56)|(KKK7<<49)|(KKK7<<42)|(KKK7<<35)|(KKK7<<28)|(KKK7<<21)|(KKK7<<14)|(KKK7<<7),
 
535
 (KKK7<<56)|(KKK7<<49)|(KKK7<<42)|(KKK7<<35)|(KKK7<<28)|(KKK7<<21)|(KKK7<<14)|(KKK7<<7)|KKK7,
 
536
};
 
537
 
 
538
 
 
539
#define KEY_N (cur_inmd->max_keyN)
 
540
 
 
541
static gboolean load_seltab(int tblidx, int seltabidx)
 
542
{
 
543
  u_char *tbl_ch = tblch(tblidx);
 
544
  if (tbl_ch[0] < 0x80) {
 
545
    load_phr(tblidx, seltab[seltabidx]);
 
546
    return TRUE;
 
547
  }
 
548
 
 
549
  int len = u8cpy(seltab[seltabidx], (char *)tbl_ch);
 
550
  seltab[seltabidx][len] = 0;
 
551
 
 
552
  return FALSE;
 
553
}
 
554
 
 
555
 
 
556
static char* load_tblidx(int tblidx)
 
557
{
 
558
  char tt[MAX_CIN_PHR];
 
559
  u_char *tbl_ch = tblch(tblidx);
 
560
  if (tbl_ch[0] < 0x80) {
 
561
    load_phr(tblidx, tt);
 
562
  } else {
 
563
    int len = u8cpy(tt, (char *)tbl_ch);
 
564
    tt[len] = 0;
 
565
  }
 
566
 
 
567
  return strdup(tt);
 
568
}
 
569
 
 
570
 
 
571
void set_gtab_input_error_color();
 
572
static void bell_err()
 
573
{
 
574
  if (test_mode)
 
575
    return;
 
576
 
 
577
  bell();
 
578
  set_gtab_input_error_color();
 
579
}
 
580
 
 
581
gboolean cmp_inmd_idx(regex_t *reg, int idx)
 
582
{
 
583
  u_int64_t kk=CONVT2(cur_inmd, idx);
 
584
  char ts[32];
 
585
  int tsN=0;
 
586
 
 
587
  ts[tsN++]= ' ';
 
588
 
 
589
  int i;
 
590
  for(i=0; i < KEY_N; i++) {
 
591
    char c = (kk >> (LAST_K_bitN - i*cur_inmd->keybits)) & cur_inmd->kmask;
 
592
    if (!c)
 
593
      break;
 
594
    ts[tsN++] = c + '0';
 
595
  }
 
596
 
 
597
  ts[tsN++]= ' ';
 
598
  ts[tsN]=0;
 
599
 
 
600
  return regexec(reg, ts, 0, 0, 0);
 
601
}
 
602
 
 
603
int page_len()
 
604
{
 
605
  return (_gtab_space_auto_first & GTAB_space_auto_first_any) ?
 
606
  cur_inmd->M_DUP_SEL+1:cur_inmd->M_DUP_SEL;
 
607
}
 
608
 
 
609
static void page_no_str(char tstr[])
 
610
{
 
611
  if (ggg.wild_mode || ggg.gtab_buf_select) {
 
612
    int pgN = (ggg.total_matchN + cur_inmd->M_DUP_SEL - 1) / cur_inmd->M_DUP_SEL;
 
613
    if (pgN < 2)
 
614
      return;
 
615
 
 
616
    int pg = ggg.gtab_buf_select ? ggg.pg_idx : ggg.wild_page;
 
617
    sprintf(tstr, "%d/%d", pg /cur_inmd->M_DUP_SEL + 1, pgN);
 
618
  } else {
 
619
    int pgN = (ggg.E1 - ggg.S1 + page_len() - 1) /page_len();
 
620
 
 
621
    if (pgN < 2)
 
622
      return;
 
623
 
 
624
    sprintf(tstr, "%d/%d", (ggg.pg_idx - ggg.S1)/page_len()+1, pgN);
 
625
  }
 
626
}
 
627
 
 
628
char *htmlspecialchars(char *s, char out[])
 
629
{
 
630
  struct {
 
631
    char c;
 
632
    char *str;
 
633
  } chs[]= {{'>',"gt"}, {'<',"lt"}, {'&',"amp"}
 
634
#if 0
 
635
  , {' ',"nbsp"}
 
636
#endif
 
637
  };
 
638
  int chsN=sizeof(chs)/sizeof(chs[0]);
 
639
 
 
640
  int outn=0;
 
641
  while (*s) {
 
642
    int sz = utf8_sz(s);
 
643
    int i;
 
644
    for(i=0; i<chsN; i++)
 
645
      if (chs[i].c==*s)
 
646
        break;
 
647
    if (i==chsN) {
 
648
      memcpy(&out[outn],s, sz);
 
649
      outn+=sz;
 
650
      s+=sz;
 
651
    }
 
652
    else {
 
653
      out[outn++]='&';
 
654
      int len=strlen(chs[i].str);
 
655
      memcpy(&out[outn], chs[i].str, len);
 
656
      outn+=len;
 
657
      out[outn++]=';';
 
658
      s++;
 
659
    }
 
660
  }
 
661
 
 
662
  out[outn]=0;
 
663
  return out;
 
664
}
 
665
 
 
666
 
 
667
void disp_selection0(gboolean phrase_selected, gboolean force_disp)
 
668
{
 
669
  char pgstr[32];
 
670
  pgstr[0]=0;
 
671
  page_no_str(pgstr);
 
672
 
 
673
  if (!gtab_vertical_select_on()) {
 
674
    if (ggg.more_pg)
 
675
      set_page_label(pgstr);
 
676
    else
 
677
      clear_page_label();
 
678
  }
 
679
 
 
680
  char tt[1024];
 
681
  tt[0]=0;
 
682
  char uu[MAX_CIN_PHR];
 
683
 
 
684
  int ofs;
 
685
  if (!ggg.wild_mode && ggg.exa_match && (_gtab_space_auto_first & GTAB_space_auto_first_any)) {
 
686
    strcat(tt, htmlspecialchars(seltab[0], uu));
 
687
    if (gtab_vertical_select_on())
 
688
      strcat(tt, "\n");
 
689
    else
 
690
      strcat(tt, " ");
 
691
    ofs = 1;
 
692
  } else {
 
693
    ofs = 0;
 
694
  }
 
695
 
 
696
 
 
697
  int i,max_i;
 
698
  for(max_i = cur_inmd->M_DUP_SEL + ofs-1; max_i>=0; max_i--)
 
699
    if (seltab[max_i][0])
 
700
      break;
 
701
 
 
702
  for(i=ofs; i<= max_i; i++) {
 
703
    if (seltab[i][0]) {
 
704
      char selback[MAX_CIN_PHR+16];
 
705
      htmlspecialchars(seltab[i], selback);
 
706
 
 
707
      utf8cpy(uu, &cur_inmd->selkey[i - ofs]);
 
708
      char vvv[16];
 
709
      char www[1024];
 
710
      sprintf(www, "<span foreground=\"%s\">%s</span>", hime_sel_key_color, htmlspecialchars(uu, vvv));
 
711
      strcat(tt, www);
 
712
 
 
713
      if (gtab_vertical_select_on())
 
714
        strcat(tt, " ");
 
715
 
 
716
      if (phrase_selected && i==ggg.sel1st_i) {
 
717
        strcat(tt, "<span foreground=\"red\">");
 
718
        strcat(strcat(tt, selback), " ");
 
719
        strcat(tt, "</span>");
 
720
      } else {
 
721
        char uu[MAX_CIN_PHR];
 
722
 
 
723
        if (gtab_vertical_select_on()) {
 
724
          utf8cpy_bytes(uu, selback, 120);
 
725
          strcat(tt, uu);
 
726
        } else {
 
727
          char *p = selback;
 
728
 
 
729
          static char *skip[]={"http://", "ftp://", "https://", NULL};
 
730
 
 
731
          int j;
 
732
          for(j=0; skip[j]; j++)
 
733
            if (!strncmp(seltab[i], skip[j], strlen(skip[j]))) {
 
734
              p+=strlen(skip[j]);
 
735
              break;
 
736
            }
 
737
 
 
738
          utf8cpy_bytes(uu, p, 6 * 3);
 
739
          strcat(strcat(tt, uu), " ");
 
740
        }
 
741
      }
 
742
 
 
743
      if (gtab_vertical_select_on())
 
744
        strcat(tt, "\n");
 
745
    } else {
 
746
      extern gboolean b_use_full_space;
 
747
 
 
748
      if (!gtab_vertical_select_on() && gtab_disp_partial_match_on()) {
 
749
         if (b_use_full_space)
 
750
           strcat(tt, " 　 ");
 
751
         else {
 
752
           strcat(tt, "   ");
 
753
         }
 
754
      }
 
755
    }
 
756
  }
 
757
 
 
758
  if (gtab_vertical_select_on() && pgstr[0]) {
 
759
    char tstr2[16];
 
760
    sprintf(tstr2, "(%s)", pgstr);
 
761
    strcat(tt, tstr2);
 
762
  }
 
763
 
 
764
  int len = strlen(tt);
 
765
  if (len && tt[len-1] == '\n')
 
766
    tt[len-1] = 0;
 
767
 
 
768
  if (gtab_pre_select_or_partial_on() || ggg.wild_mode || ggg.spc_pressed || ggg.last_full || force_disp) {
 
769
    disp_gtab_sel(tt);
 
770
  }
 
771
}
 
772
 
 
773
 
 
774
void disp_selection(gboolean phrase_selected)
 
775
{
 
776
  disp_selection0(phrase_selected, FALSE);
 
777
}
 
778
 
 
779
void wildcard()
 
780
{
 
781
  int i,t, wild_ofs=0;
 
782
  int found=0;
 
783
  regex_t reg;
 
784
 
 
785
  ClrSelArea();
 
786
  clr_seltab();
 
787
  /* printf("wild %d %d %d %d\n", ggg.inch[0], ggg.inch[1], ggg.inch[2], ggg.inch[3]); */
 
788
  ggg.defselN=0;
 
789
  char regstr[32];
 
790
  int regstrN=0;
 
791
 
 
792
  regstr[regstrN++]=' ';
 
793
 
 
794
  for(i=0; i < KEY_N; i++) {
 
795
    if (!ggg.inch[i])
 
796
      break;
 
797
    if (ggg.inch[i] == cur_inmd->WILD_STAR) {
 
798
      regstr[regstrN++]='.';
 
799
      regstr[regstrN++]='*';
 
800
    } else
 
801
    if (ggg.inch[i] == cur_inmd->WILD_QUES) {
 
802
      regstr[regstrN++]='.';
 
803
    } else {
 
804
      char c = ggg.inch[i] + '0';         // start from '0'
 
805
      if (strchr("*.\\()[]", c))
 
806
      regstr[regstrN++] = '\\';
 
807
      regstr[regstrN++]=c;
 
808
    }
 
809
  }
 
810
 
 
811
  regstr[regstrN++]=' ';
 
812
  regstr[regstrN]=0;
 
813
 
 
814
//  dbg("regstr %s\n", regstr);
 
815
 
 
816
  if (regcomp(&reg, regstr, 0)) {
 
817
    dbg("regcomp failed\n");
 
818
    return;
 
819
  }
 
820
 
 
821
  for(t=0; t< cur_inmd->DefChars && ggg.defselN < cur_inmd->M_DUP_SEL; t++) {
 
822
    if (cmp_inmd_idx(&reg, t))
 
823
      continue;
 
824
 
 
825
    if (wild_ofs >= ggg.wild_page) {
 
826
      load_seltab(t, ggg.defselN);
 
827
      ggg.defselN++;
 
828
    } else
 
829
      wild_ofs++;
 
830
 
 
831
    found=1;
 
832
  } /* for t */
 
833
 
 
834
 
 
835
  if (!found) {
 
836
    bell_err();
 
837
  } else
 
838
  if (!ggg.wild_page) {
 
839
    ggg.total_matchN = 0;
 
840
 
 
841
    for(t=0; t< cur_inmd->DefChars; t++)
 
842
      if (!cmp_inmd_idx(&reg, t))
 
843
        ggg.total_matchN++;
 
844
 
 
845
  }
 
846
 
 
847
  if (ggg.total_matchN > cur_inmd->M_DUP_SEL)
 
848
    ggg.more_pg = 1;
 
849
 
 
850
  regfree(&reg);
 
851
  disp_selection(FALSE);
 
852
}
 
853
 
 
854
static char *ptr_selkey(KeySym key)
 
855
{
 
856
  if (key>= XK_KP_0 && key<= XK_KP_9)
 
857
    key-= XK_KP_0 - '0';
 
858
  return strchr(cur_inmd->selkey, key);
 
859
}
 
860
 
 
861
 
 
862
void init_gtab_pho_query_win();
 
863
int feedkey_pho(KeySym xkey, int state);
 
864
 
 
865
void set_gtab_target_displayed()
 
866
{
 
867
  close_gtab_pho_win();
 
868
}
 
869
 
 
870
gboolean is_gtab_query_mode()
 
871
{
 
872
  return poo.same_pho_query_state == SAME_PHO_QUERY_pho_select;
 
873
}
 
874
 
 
875
void reset_gtab_all()
 
876
{
 
877
  if (!cur_inmd)
 
878
    return;
 
879
 
 
880
  ClrIn();
 
881
  ClrSelArea();
 
882
}
 
883
 
 
884
 
 
885
static gboolean has_wild_card()
 
886
{
 
887
  int i;
 
888
 
 
889
  for(i=0; i < cur_inmd->MaxPress; i++)
 
890
    if (ggg.inch[i]>= cur_inmd->WILD_QUES) {
 
891
      return TRUE;
 
892
    }
 
893
 
 
894
  return FALSE;
 
895
}
 
896
 
 
897
static void proc_wild_disp()
 
898
{
 
899
   DispInArea();
 
900
   ggg.wild_page = 0;
 
901
   wildcard();
 
902
   disp_selection(0);
 
903
}
 
904
 
 
905
gboolean full_char_proc(KeySym keysym);
 
906
void insert_gbuf_cursor_char(char ch);
 
907
gboolean gtab_pre_select_shift(KeySym key, int kbstate);
 
908
 
 
909
gboolean shift_char_proc(KeySym key, int kbstate)
 
910
{
 
911
    if (key >= 127)
 
912
      return FALSE;
 
913
 
 
914
#if 0
 
915
    if (kbstate & LockMask) {
 
916
      if (key >= 'a' && key <= 'z')
 
917
        key-=0x20;
 
918
    } else {
 
919
      if (key >= 'A' && key <= 'Z')
 
920
        key+=0x20;
 
921
    }
 
922
#endif
 
923
 
 
924
    if (gtab_pre_select_shift(key, kbstate))
 
925
      return TRUE;
 
926
 
 
927
    if (current_CS->b_half_full_char)
 
928
      return full_char_proc(key);
 
929
 
 
930
    if (ggg.gbufN)
 
931
      insert_gbuf_cursor_char(key);
 
932
    else
 
933
      send_ascii(key);
 
934
 
 
935
    return TRUE;
 
936
}
 
937
 
 
938
extern GtkWidget *gwin_pho;
 
939
gboolean feed_phrase(KeySym ksym, int state);
 
940
int gtab_buf_backspace();
 
941
gboolean output_gbuf();
 
942
int show_buf_select();
 
943
void gbuf_next_pg(), gbuf_prev_pg();
 
944
void show_win_gtab();
 
945
int gbuf_cursor_left();
 
946
int gbuf_cursor_right();
 
947
int gbuf_cursor_home();
 
948
int gbuf_cursor_end();
 
949
int gtab_buf_delete();
 
950
void set_gbuf_c_sel(int v);
 
951
void set_gtab_user_head();
 
952
KeySym keypad_proc(KeySym xkey);
 
953
void save_gtab_buf_phrase(KeySym key);
 
954
gboolean save_gtab_buf_shift_enter();
 
955
gboolean win_sym_page_up(), win_sym_page_down();
 
956
u_int64_t vmaskci;
 
957
gboolean gtab_pre_select_idx(int c);
 
958
void save_CS_current_to_temp();
 
959
void tsin_set_eng_ch(int nmod);
 
960
 
 
961
gboolean feedkey_gtab(KeySym key, int kbstate)
 
962
{
 
963
  int i,j=0;
 
964
  int inkey=0;
 
965
  char *pselkey= NULL;
 
966
  gboolean phrase_selected = FALSE;
 
967
  char seltab_phrase[MAX_SELKEY];
 
968
  gboolean is_keypad = FALSE;
 
969
  gboolean shift_m = (kbstate & ShiftMask) > 0;
 
970
//  gboolean ctrl_m = (kbstate & ControlMask) > 0;
 
971
  gboolean capslock_on = (kbstate & LockMask);
 
972
  gboolean is_dayi = !strncmp(cur_inmd->filename, "dayi", 4);
 
973
 
 
974
  bzero(seltab_phrase, sizeof(seltab_phrase));
 
975
 
 
976
//  dbg("uuuuu %x %x   shift,ctrl:%d,%d\n", key, kbstate, shift_m, ctrl_m);
 
977
 
 
978
  if (!cur_inmd)
 
979
    return 0;
 
980
 
 
981
  if ((tsin_chinese_english_toggle_key == TSIN_CHINESE_ENGLISH_TOGGLE_KEY_CapsLock) &&
 
982
      (key == XK_Caps_Lock)){
 
983
    // The CapLock status may be incorrect when XK_Caps_Lock is pressed.
 
984
    gboolean new_tsin_pho_mode = ! gdk_keymap_get_caps_lock_state(gdk_keymap_get_default());
 
985
    if (current_CS->tsin_pho_mode != new_tsin_pho_mode) {
 
986
      current_CS->tsin_pho_mode = new_tsin_pho_mode;
 
987
      save_CS_current_to_temp();
 
988
      tsin_set_eng_ch(new_tsin_pho_mode);
 
989
    }
 
990
  }
 
991
 
 
992
  if ((kbstate & (Mod1Mask|Mod4Mask|Mod5Mask|ControlMask))==ControlMask
 
993
     && key>='1' && key<='9' && ggg.gbufN) {
 
994
    save_gtab_buf_phrase(key);
 
995
    return 1;
 
996
  }
 
997
 
 
998
  if (ggg.gbufN && key==XK_Tab)
 
999
    return 1;
 
1000
 
 
1001
   if ((key==XK_Shift_L||key==XK_Shift_R) && !key_press_time) {
 
1002
     key_press_time = current_time();
 
1003
     key_press_time_ctrl = 0;
 
1004
   } else
 
1005
  if ((key==XK_Control_L||key==XK_Control_R) && !key_press_time_ctrl && tss.pre_selN) {
 
1006
    key_press_time_ctrl = current_time();
 
1007
    return TRUE;
 
1008
  } else {
 
1009
    key_press_time_ctrl = 0;
 
1010
    key_press_time = 0;
 
1011
  }
 
1012
 
 
1013
  if (kbstate & (Mod1Mask|Mod4Mask|Mod5Mask|ControlMask)) {
 
1014
    return 0;
 
1015
  }
 
1016
 
 
1017
  if (poo.same_pho_query_state == SAME_PHO_QUERY_pho_select)
 
1018
    return feedkey_pho(key, 0);
 
1019
 
 
1020
  if (poo.same_pho_query_state == SAME_PHO_QUERY_none && gwin_pho &&
 
1021
    GTK_WIDGET_VISIBLE(gwin_pho))
 
1022
     hide_win_pho();
 
1023
 
 
1024
  if (!tsin_pho_mode()) {
 
1025
    if (key < 0x20 || key>=0x7f)
 
1026
      goto shift_proc;
 
1027
 
 
1028
    if (capslock_on && hime_capslock_lower)
 
1029
      case_inverse((KeySym *)&key, shift_m);
 
1030
 
 
1031
    if (ggg.gbufN)
 
1032
      insert_gbuf_cursor_char(key);
 
1033
    else
 
1034
      send_ascii(key);
 
1035
 
 
1036
    return 1;
 
1037
  }
 
1038
 
 
1039
 
 
1040
  int lcase;
 
1041
  lcase = tolower(key);
 
1042
  int ucase;
 
1043
  ucase = toupper(key);
 
1044
  if (key < 127 && cur_inmd->keymap[key]) {
 
1045
     if (key < 'A' || key > 'z' || (key > 'Z'  && key < 'a') )
 
1046
       goto shift_proc;
 
1047
     if (cur_inmd->keymap[lcase] != cur_inmd->keymap[ucase])
 
1048
       goto next;
 
1049
 
 
1050
  }
 
1051
 
 
1052
 
 
1053
shift_proc:
 
1054
  if (shift_m && !strchr(cur_inmd->selkey, key) && !ggg.more_pg && key>=' ' && key < 0x7e &&
 
1055
       key!='*' && (key!='?' || (gtab_shift_phrase_key && !ggg.ci))) {
 
1056
    if (gtab_shift_phrase_key) {
 
1057
      if (tss.pre_selN && shift_char_proc(key, kbstate))
 
1058
        return TRUE;
 
1059
      if (feed_phrase(key, kbstate))
 
1060
        return TRUE;
 
1061
    } else {
 
1062
      if (!cur_inmd->keymap[key] || (lcase != ucase &&
 
1063
           cur_inmd->keymap[lcase]==cur_inmd->keymap[ucase]))
 
1064
        return shift_char_proc(key, kbstate);
 
1065
    }
 
1066
  }
 
1067
 
 
1068
  gboolean has_wild;
 
1069
  has_wild = FALSE;
 
1070
 
 
1071
  switch (key) {
 
1072
    case XK_BackSpace:
 
1073
      ggg.last_idx=0;
 
1074
      ggg.spc_pressed=0;
 
1075
      ggg.sel1st_i=MAX_SELKEY-1;
 
1076
      clear_gtab_input_error_color();
 
1077
      hide_gtab_pre_sel();
 
1078
 
 
1079
      if (ggg.ci==0) {
 
1080
        if (AUTO_SELECT_BY_PHRASE)
 
1081
          return gtab_buf_backspace();
 
1082
        else
 
1083
          return 0;
 
1084
      }
 
1085
 
 
1086
      if (ggg.ci>0)
 
1087
        ggg.inch[--ggg.ci]=0;
 
1088
 
 
1089
      if (has_wild_card()) {
 
1090
        proc_wild_disp();
 
1091
        return 1;
 
1092
      }
 
1093
 
 
1094
 
 
1095
      ggg.wild_mode=0;
 
1096
      ggg.invalid_spc = FALSE;
 
1097
      if (ggg.ci==1 && cur_inmd->use_quick) {
 
1098
        int i;
 
1099
        clr_seltab();
 
1100
        for(i=0;i<cur_inmd->M_DUP_SEL;i++)
 
1101
          utf8cpy(seltab[i], (char *)cur_inmd->qkeys->quick1[ggg.inch[0]-1][i]);
 
1102
 
 
1103
        ggg.defselN=cur_inmd->M_DUP_SEL;
 
1104
        DispInArea();
 
1105
        goto Disp_opt;
 
1106
      } else
 
1107
      if (ggg.ci==2 && cur_inmd->use_quick) {
 
1108
        int i;
 
1109
        clr_seltab();
 
1110
        for(i=0;i<cur_inmd->M_DUP_SEL;i++)
 
1111
          utf8cpy(seltab[i], (char *)cur_inmd->qkeys->quick2[ggg.inch[0]-1][ggg.inch[1]-1][i]);
 
1112
 
 
1113
        ggg.defselN=cur_inmd->M_DUP_SEL;
 
1114
        DispInArea();
 
1115
        goto Disp_opt;
 
1116
      }
 
1117
 
 
1118
      break;
 
1119
    case XK_KP_Enter:
 
1120
    case XK_Return:
 
1121
      if (AUTO_SELECT_BY_PHRASE) {
 
1122
        hide_gtab_pre_sel();
 
1123
        if (shift_m) {
 
1124
          return save_gtab_buf_shift_enter();
 
1125
        } else
 
1126
          return output_gbuf();
 
1127
      }
 
1128
      else
 
1129
        return 0;
 
1130
    case XK_Up:
 
1131
      if (gtab_has_input())
 
1132
        return TRUE;
 
1133
      return FALSE;
 
1134
    case XK_Down:
 
1135
    case XK_KP_Down:
 
1136
      if (AUTO_SELECT_BY_PHRASE)
 
1137
        return show_buf_select();
 
1138
      else
 
1139
        return 0;
 
1140
    case XK_Escape:
 
1141
      hide_gtab_pre_sel();
 
1142
      if (ggg.gtab_buf_select) {
 
1143
        ggg.gtab_buf_select = 0;
 
1144
        reset_gtab_all();
 
1145
        ClrSelArea();
 
1146
        if (hime_pop_up_win && !gtab_has_input())
 
1147
          hide_win_gtab();
 
1148
        return 1;
 
1149
      }
 
1150
      ClrSelArea();
 
1151
      close_gtab_pho_win();
 
1152
      if (ggg.ci) {
 
1153
        reset_gtab_all();
 
1154
        return 1;
 
1155
      } else {
 
1156
        if (ggg.gbufN) {
 
1157
          set_gtab_user_head();
 
1158
          return 1;
 
1159
        }
 
1160
        ClrIn();
 
1161
        return 0;
 
1162
      }
 
1163
    case XK_Prior:
 
1164
    case XK_KP_Prior:
 
1165
    case XK_KP_Subtract:
 
1166
      if (ggg.wild_mode) {
 
1167
        if (ggg.wild_page >= cur_inmd->M_DUP_SEL) ggg.wild_page-=cur_inmd->M_DUP_SEL;
 
1168
        wildcard();
 
1169
        return 1;
 
1170
      } else
 
1171
      if (ggg.more_pg) {
 
1172
        if (ggg.gtab_buf_select) {
 
1173
          gbuf_prev_pg();
 
1174
          return 1;
 
1175
        }
 
1176
 
 
1177
        ggg.pg_idx -= page_len();
 
1178
        if (ggg.pg_idx < ggg.S1)
 
1179
          ggg.pg_idx = ggg.S1;
 
1180
 
 
1181
        goto next_pg;
 
1182
      }
 
1183
 
 
1184
      if (key==XK_KP_Subtract)
 
1185
        goto keypad_proc;
 
1186
 
 
1187
      return win_sym_page_up();
 
1188
    case XK_Next:
 
1189
    case XK_KP_Next:
 
1190
    case XK_KP_Add:
 
1191
      if (ggg.more_pg) {
 
1192
        if (ggg.gtab_buf_select) {
 
1193
          gbuf_next_pg();
 
1194
          return 1;
 
1195
        }
 
1196
next_page:
 
1197
//        dbg("more...\n");
 
1198
        ggg.pg_idx += page_len();
 
1199
        if (ggg.pg_idx >=ggg.E1)
 
1200
          ggg.pg_idx = ggg.S1;
 
1201
        goto next_pg;
 
1202
      } else {
 
1203
        if (key==XK_KP_Add)
 
1204
          goto keypad_proc;
 
1205
        if (win_sym_page_down())
 
1206
          return TRUE;
 
1207
        if (!ggg.gtab_buf_select && ggg.gbufN && AUTO_SELECT_BY_PHRASE)
 
1208
          return show_buf_select();
 
1209
        return FALSE;
 
1210
      }
 
1211
    case ' ':
 
1212
      hide_gtab_pre_sel();
 
1213
 
 
1214
      if (ggg.invalid_spc && gtab_invalid_key_in)
 
1215
        ClrIn();
 
1216
 
 
1217
      if (!gtab_invalid_key_in && ggg.spc_pressed && ggg.invalid_spc) {
 
1218
        ClrIn();
 
1219
        return 1;
 
1220
      }
 
1221
 
 
1222
      has_wild = has_wild_card();
 
1223
 
 
1224
//      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);
 
1225
 
 
1226
      if (ggg.wild_mode) {
 
1227
        // request from tetralet
 
1228
        if (!ggg.wild_page && ggg.total_matchN < cur_inmd->M_DUP_SEL) {
 
1229
          ggg.sel1st_i = 0;
 
1230
          goto direct_select;
 
1231
        }
 
1232
 
 
1233
        ggg.wild_page += cur_inmd->M_DUP_SEL;
 
1234
        if (ggg.wild_page >= ggg.total_matchN)
 
1235
          ggg.wild_page=0;
 
1236
 
 
1237
        wildcard();
 
1238
        ggg.spc_pressed = TRUE;
 
1239
        return 1;
 
1240
      } else
 
1241
      if (ggg.more_pg && !(_gtab_space_auto_first & GTAB_space_auto_first_any)) {
 
1242
        if (ggg.gtab_buf_select) {
 
1243
          gbuf_next_pg();
 
1244
          return 1;
 
1245
        }
 
1246
        else
 
1247
          goto next_page;
 
1248
      } else
 
1249
      if (ggg.ci==0) {
 
1250
        if (current_CS->b_half_full_char)
 
1251
          return full_char_proc(key);
 
1252
 
 
1253
        if (ggg.gbufN) {
 
1254
          output_gbuf();
 
1255
        } else
 
1256
          return 0;
 
1257
      } else
 
1258
      if (!has_wild) {
 
1259
//        dbg("iii %d  ggg.defselN:%d   %d\n", ggg.sel1st_i, ggg.defselN, cur_inmd->M_DUP_SEL);
 
1260
        if (_gtab_space_auto_first == GTAB_space_auto_first_any && seltab[0][0] &&
 
1261
            ggg.sel1st_i==MAX_SELKEY-1) {
 
1262
          ggg.sel1st_i = 0;
 
1263
        }
 
1264
 
 
1265
        if (_gtab_space_auto_first == GTAB_space_auto_first_nofull && ggg.exa_match > 1
 
1266
            && !AUTO_SELECT_BY_PHRASE && gtab_dup_select_bell)
 
1267
          bell();
 
1268
 
 
1269
        if (seltab[ggg.sel1st_i][0]) {
 
1270
//          dbg("ggg.last_full %d %d\n", ggg.last_full,ggg.spc_pressed);
 
1271
          if (gtab_full_space_auto_first || ggg.spc_pressed) {
 
1272
direct_select:
 
1273
            if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input) {
 
1274
//              dbg("ins ggg.kval %x\n", ggg.kval);
 
1275
              insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
 
1276
            }
 
1277
            else
 
1278
              putstr_inp(seltab[ggg.sel1st_i]);  /* select 1st */
 
1279
            return 1;
 
1280
          }
 
1281
        }
 
1282
      }
 
1283
 
 
1284
      ggg.last_full=0;
 
1285
      ggg.spc_pressed=1;
 
1286
//      dbg("spc_pressed=1\n");
 
1287
 
 
1288
      if (has_wild) {
 
1289
        ggg.wild_page=0;
 
1290
        ggg.wild_mode=1;
 
1291
        wildcard();
 
1292
        return 1;
 
1293
      }
 
1294
 
 
1295
      break;
 
1296
    case '?':
 
1297
      if (!gtab_que_wild_card) {
 
1298
        inkey=cur_inmd->keymap[key];
 
1299
        if ((inkey && (inkey!=cur_inmd->WILD_QUES && inkey!=cur_inmd->WILD_STAR)) || ptr_selkey(key))
 
1300
          goto next;
 
1301
        if (AUTO_SELECT_BY_PHRASE && ggg.gbufN) {
 
1302
          insert_gbuf_cursor_char(key);
 
1303
          return 1;
 
1304
        } else {
 
1305
          if (current_CS->b_half_full_char)
 
1306
            return full_char_proc(key);
 
1307
                  else
 
1308
            return 0;
 
1309
                }
 
1310
      }
 
1311
    case '*':
 
1312
      if (tss.pre_selN && shift_char_proc(key, kbstate))
 
1313
        return TRUE;
 
1314
 
 
1315
      if (current_CS->b_half_full_char)
 
1316
        return full_char_proc(key);
 
1317
 
 
1318
      inkey=cur_inmd->keymap[key];
 
1319
      if ((inkey && (inkey!=cur_inmd->WILD_STAR && inkey!=cur_inmd->WILD_QUES)) || ptr_selkey(key)) {
 
1320
//        dbg("%d %d\n", inkey, cur_inmd->WILD_STAR);
 
1321
        goto next;
 
1322
      }
 
1323
      if (ggg.ci< cur_inmd->MaxPress) {
 
1324
        ggg.inch[ggg.ci++]=inkey;
 
1325
        DispInArea();
 
1326
 
 
1327
        if (hime_pop_up_win)
 
1328
          show_win_gtab();
 
1329
 
 
1330
        ggg.total_matchN = 0;
 
1331
        ggg.wild_page=0;
 
1332
        ggg.wild_mode=1;
 
1333
        wildcard();
 
1334
        return 1;
 
1335
      }
 
1336
      return 0;
 
1337
    case XK_Left:
 
1338
    case XK_KP_Left:
 
1339
      return gbuf_cursor_left();
 
1340
    case XK_Right:
 
1341
    case XK_KP_Right:
 
1342
      return gbuf_cursor_right();
 
1343
    case XK_Home:
 
1344
    case XK_KP_Home:
 
1345
      return gbuf_cursor_home();
 
1346
    case XK_End:
 
1347
    case XK_KP_End:
 
1348
      return gbuf_cursor_end();
 
1349
    case XK_Delete:
 
1350
    case XK_KP_Delete:
 
1351
      return gtab_buf_delete();
 
1352
    case XK_Shift_L:
 
1353
    case XK_Shift_R:
 
1354
    case XK_Control_R:
 
1355
    case XK_Control_L:
 
1356
    case XK_Alt_L:
 
1357
    case XK_Alt_R:
 
1358
    case XK_Caps_Lock:
 
1359
      return 0;
 
1360
    case '`':
 
1361
      if (!cur_inmd->keymap[key]) {
 
1362
        poo.same_pho_query_state = SAME_PHO_QUERY_gtab_input;
 
1363
        reset_gtab_all();
 
1364
        disp_gtab_sel(_("輸入要查的同音字，接著在注音視窗選字"));
 
1365
        if (hime_pop_up_win)
 
1366
          show_win_gtab();
 
1367
        disp_pho_sel("");
 
1368
        init_gtab_pho_query_win();
 
1369
        return 1;
 
1370
      }
 
1371
    default:
 
1372
next:
 
1373
 
 
1374
      if (key < 0x7f)
 
1375
        inkey= cur_inmd->keymap[key];
 
1376
      else
 
1377
        inkey = 0;
 
1378
 
 
1379
      if (shift_m && !inkey && !tss.ctrl_pre_sel &&
 
1380
        tss.pre_selN && shift_char_proc(key, kbstate))
 
1381
        return TRUE;
 
1382
 
 
1383
      clear_gtab_input_error_color();
 
1384
 
 
1385
      if (ggg.invalid_spc && gtab_invalid_key_in) {
 
1386
        ClrIn();
 
1387
      }
 
1388
      if (key>=XK_KP_0 && key<=XK_KP_9) {
 
1389
        if (!ggg.ci) {
 
1390
          if (ggg.gbufN) {
 
1391
            insert_gbuf_cursor_char(key - XK_KP_0 + '0');
 
1392
            return 1;
 
1393
          } else
 
1394
            return 0;
 
1395
        }
 
1396
        if (is_dayi) {
 
1397
          key = key - XK_KP_0 + '0';
 
1398
          is_keypad = TRUE;
 
1399
        }
 
1400
      }
 
1401
 
 
1402
      int keypad;
 
1403
keypad_proc:
 
1404
      keypad = keypad_proc(key);
 
1405
      if (keypad) {
 
1406
        if (!ggg.ci) {
 
1407
          if (ggg.gbufN) {
 
1408
            insert_gbuf_cursor_char(keypad);
 
1409
            return 1;
 
1410
          } else
 
1411
            return 0;
 
1412
        }
 
1413
      }
 
1414
      char *pendkey = strchr(cur_inmd->endkey, key);
 
1415
 
 
1416
      pselkey=ptr_selkey(key);
 
1417
 
 
1418
      if (!pselkey && (key < 32 || key > 0x7e) && (gtab_full_space_auto_first || ggg.spc_pressed)) {
 
1419
//        dbg("%x %x ggg.sel1st_i:%d  '%c'\n", pselkey, key, ggg.sel1st_i, seltab[ggg.sel1st_i][0]);
 
1420
        if (seltab[ggg.sel1st_i][0]) {
 
1421
          if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
 
1422
            insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
 
1423
          else
 
1424
            putstr_inp(seltab[ggg.sel1st_i]);  /* select 1st */
 
1425
        }
 
1426
 
 
1427
        return 0;
 
1428
      }
 
1429
 
 
1430
 
 
1431
 
 
1432
//        dbg("ggg.spc_pressed %d %d %d is_keypad:%d\n", ggg.spc_pressed, ggg.last_full, cur_inmd->MaxPress, is_keypad);
 
1433
 
 
1434
#if 1 // for dayi, testcase :  6 space keypad6
 
1435
      int vv = pselkey - cur_inmd->selkey;
 
1436
      if (pselkey && tss.pre_selN && !ggg.gtab_buf_select && (tss.ctrl_pre_sel||
 
1437
          ((!inkey||ggg.spc_pressed||is_keypad)&&! gtab_disp_partial_match_on() && !gtab_pre_select_on()))) {
 
1438
        if (gtab_pre_select_idx(vv))
 
1439
          return TRUE;
 
1440
      } else
 
1441
      if (( (ggg.spc_pressed||ggg.last_full||is_keypad) ||(ggg.wild_mode && (!inkey ||pendkey)) || ggg.gtab_buf_select) && pselkey) {
 
1442
        if ((_gtab_space_auto_first & GTAB_space_auto_first_any) && !ggg.wild_mode)
 
1443
          vv++;
 
1444
 
 
1445
        if (vv<0)
 
1446
          vv=9;
 
1447
 
 
1448
        if (seltab[vv][0]) {
 
1449
          if (AUTO_SELECT_BY_PHRASE && !same_query_show_pho_win()) {
 
1450
            if (ggg.gtab_buf_select && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
 
1451
              set_gbuf_c_sel(vv);
 
1452
            else
 
1453
              insert_gbuf_cursor1_cond(seltab[vv], ggg.kval, ggg.exa_match);
 
1454
          }
 
1455
          else {
 
1456
            putstr_inp(seltab[vv]);
 
1457
          }
 
1458
 
 
1459
          if (hime_pop_up_win && !gtab_has_input())
 
1460
            hide_win_gtab();
 
1461
 
 
1462
          return 1;
 
1463
        }
 
1464
      }
 
1465
#endif
 
1466
 
 
1467
//      dbg("iii %x sel1st_i:%d auto:%d\n", pselkey, ggg.sel1st_i, AUTO_SELECT_BY_PHRASE);
 
1468
      if (seltab[ggg.sel1st_i][0] && !ggg.wild_mode &&
 
1469
           (gtab_full_space_auto_first||ggg.spc_pressed||ggg.last_full) ) {
 
1470
        if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
 
1471
          insert_gbuf_cursor1_cond(seltab[ggg.sel1st_i], ggg.kval, ggg.exa_match);
 
1472
        else
 
1473
          putstr_inp(seltab[ggg.sel1st_i]);  /* select 1st */
 
1474
      }
 
1475
#if 0
 
1476
      if (key > 0x7f) {
 
1477
        return 0;
 
1478
      }
 
1479
#endif
 
1480
 
 
1481
      ggg.spc_pressed=0;
 
1482
 
 
1483
      // for cj & boshiamy to input digits
 
1484
      if (!ggg.ci && !inkey) {
 
1485
        if (current_CS->b_half_full_char)
 
1486
          return full_char_proc(key);
 
1487
        else {
 
1488
          if (ggg.gbufN && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input) {
 
1489
            insert_gbuf_cursor_char(key);
 
1490
            return 1;
 
1491
          }
 
1492
          else
 
1493
            return 0;
 
1494
        }
 
1495
      }
 
1496
 
 
1497
      if (ggg.wild_mode && inkey>=1 && ggg.ci< cur_inmd->MaxPress) {
 
1498
        ggg.inch[ggg.ci++]=inkey;
 
1499
        if (hime_pop_up_win)
 
1500
          show_win_gtab();
 
1501
        proc_wild_disp();
 
1502
        return 1;
 
1503
      }
 
1504
 
 
1505
      if (inkey>=1 && ggg.ci< cur_inmd->MaxPress) {
 
1506
        ggg.inch[ggg.ci++]=inkey;
 
1507
        hide_gtab_pre_sel();
 
1508
 
 
1509
        if (hime_pop_up_win)
 
1510
          show_win_gtab();
 
1511
        ggg.last_full=0;
 
1512
 
 
1513
        if (cur_inmd->use_quick && !pendkey) {
 
1514
          if (ggg.ci==1) {
 
1515
            int i;
 
1516
            for(i=0;i < cur_inmd->M_DUP_SEL; i++) {
 
1517
              utf8cpy(seltab[i], (char *)&cur_inmd->qkeys->quick1[inkey-1][i]);
 
1518
            }
 
1519
 
 
1520
            ggg.defselN=cur_inmd->M_DUP_SEL;
 
1521
            DispInArea();
 
1522
            goto Disp_opt;
 
1523
          } else
 
1524
          if (ggg.ci==2 && !pselkey) {
 
1525
            int i;
 
1526
            for(i=0;i < cur_inmd->M_DUP_SEL; i++) {
 
1527
              utf8cpy(seltab[i], (char *)&cur_inmd->qkeys->quick2[ggg.inch[0]-1][inkey-1][i]);
 
1528
            }
 
1529
 
 
1530
            ggg.defselN=cur_inmd->M_DUP_SEL;
 
1531
            DispInArea();
 
1532
            goto Disp_opt;
 
1533
          }
 
1534
        }
 
1535
      } else
 
1536
      if (ggg.ci == cur_inmd->MaxPress && !pselkey) {
 
1537
        bell();
 
1538
        return 1;
 
1539
      }
 
1540
 
 
1541
 
 
1542
      if (inkey) {
 
1543
        for(i=0; i < MAX_TAB_KEY_NUM64_6; i++)
 
1544
          if (ggg.inch[i]>=cur_inmd->WILD_QUES) {
 
1545
            DispInArea();
 
1546
            if (ggg.ci==cur_inmd->MaxPress) {
 
1547
              ggg.wild_mode=1;
 
1548
              ggg.wild_page=0;
 
1549
              wildcard();
 
1550
            }
 
1551
 
 
1552
            return 1;
 
1553
          }
 
1554
      } else {
 
1555
        if (!pselkey) {
 
1556
          if (current_CS->b_half_full_char)
 
1557
            return full_char_proc(key);
 
1558
          else {
 
1559
            if (key>=' ' && key<0x7f && AUTO_SELECT_BY_PHRASE && ggg.gbufN)
 
1560
              insert_gbuf_cursor_char(key);
 
1561
            else
 
1562
              return 0;
 
1563
          }
 
1564
        }
 
1565
 
 
1566
        if (ggg.defselN) {
 
1567
          goto YYYY;
 
1568
        }
 
1569
     }
 
1570
  } /* switch */
 
1571
 
 
1572
 
 
1573
  if (ggg.ci==0) {
 
1574
    ClrSelArea();
 
1575
    ClrIn();
 
1576
    return 1;
 
1577
  }
 
1578
 
 
1579
  ggg.invalid_spc = FALSE;
 
1580
  char *pendkey = NULL;
 
1581
  pendkey = strchr(cur_inmd->endkey, key);
 
1582
 
 
1583
  DispInArea();
 
1584
 
 
1585
  ggg.kval=0;
 
1586
 
 
1587
  for(i=0; i < Max_tab_key_num; i++) {
 
1588
    ggg.kval|= (u_int64_t)ggg.inch[i] << (KeyBits * (Max_tab_key_num - 1 - i));
 
1589
  }
 
1590
 
 
1591
#if 1
 
1592
  if (ggg.last_idx)
 
1593
    ggg.S1=ggg.last_idx;
 
1594
  else
 
1595
#endif
 
1596
    ggg.S1=cur_inmd->idx1[ggg.inch[0]];
 
1597
 
 
1598
//  dbg("--------- ch:%d %d val %llx  ggg.S1:%d\n", ggg.inch[0], Max_tab_key_num, ggg.kval, ggg.S1);
 
1599
 
 
1600
  int oE1;
 
1601
  oE1=cur_inmd->idx1[ggg.inch[0]+1];
 
1602
  if (cur_inmd->keybits==6)
 
1603
    vmaskci = cur_inmd->key64 ? vmask64[ggg.ci]:vmask[ggg.ci];
 
1604
  else
 
1605
    vmaskci = cur_inmd->key64 ? vmask64_7[ggg.ci]:vmask_7[ggg.ci];
 
1606
 
 
1607
  gtab_scan_pre_select(TRUE);
 
1608
 
 
1609
  while ((CONVT2(cur_inmd, ggg.S1) & vmaskci) != ggg.kval &&
 
1610
          CONVT2(cur_inmd, ggg.S1) < ggg.kval &&  ggg.S1<oE1)
 
1611
    ggg.S1++;
 
1612
 
 
1613
  ggg.pg_idx=ggg.last_idx=ggg.S1;
 
1614
 
 
1615
 
 
1616
#if 0
 
1617
  dbg("MaxPress:%d vmaskci:%llx kval:%llx ggg.ci:%d  !=%d  S1:%d  kval:%x\n", cur_inmd->MaxPress,
 
1618
  vmaskci, ggg.kval, ggg.ci,
 
1619
  ((CONVT2(cur_inmd, ggg.S1) & vmaskci)!=ggg.kval), ggg.S1);
 
1620
#endif
 
1621
 
 
1622
  if ((CONVT2(cur_inmd, ggg.S1) & vmaskci)!=ggg.kval || (ggg.wild_mode && ggg.defselN) ||
 
1623
                  ((/* ggg.ci==cur_inmd->MaxPress|| */ ggg.spc_pressed) && ggg.defselN &&
 
1624
      (pselkey && ( pendkey || ggg.spc_pressed)) ) ) {
 
1625
YYYY:
 
1626
 
 
1627
    if ((pselkey || ggg.wild_mode) && ggg.defselN) {
 
1628
      int vv = pselkey - cur_inmd->selkey;
 
1629
 
 
1630
      if ((_gtab_space_auto_first & GTAB_space_auto_first_any) && !ggg.wild_mode
 
1631
          && ggg.exa_match && (!cur_inmd->use_quick || ggg.ci!=2))
 
1632
        vv++;
 
1633
 
 
1634
      if (vv<0)
 
1635
        vv=9;
 
1636
 
 
1637
      if (seltab[vv][0]) {
 
1638
        if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
 
1639
          insert_gbuf_cursor1_cond(seltab[vv], ggg.kval, ggg.exa_match);
 
1640
        else
 
1641
          putstr_inp(seltab[vv]);
 
1642
        return 1;
 
1643
      }
 
1644
    }
 
1645
 
 
1646
    if (pselkey && !ggg.defselN)
 
1647
      return 0;
 
1648
 
 
1649
    if (gtab_invalid_key_in) {
 
1650
      if (ggg.spc_pressed) {
 
1651
        bell_err();
 
1652
        ggg.invalid_spc = TRUE;
 
1653
//        dbg("ggg.invalid_spc\n");
 
1654
      } else {
 
1655
        seltab[0][0]=0;
 
1656
        ClrSelArea();
 
1657
      }
 
1658
    } else {
 
1659
      if (gtab_dup_select_bell)
 
1660
        bell();
 
1661
 
 
1662
      if (ggg.ci>0)
 
1663
        ggg.inch[--ggg.ci]=0;
 
1664
    }
 
1665
 
 
1666
    ggg.last_idx=0;
 
1667
    DispInArea();
 
1668
    return 1;
 
1669
  }
 
1670
 
 
1671
//refill:
 
1672
 
 
1673
  j=ggg.S1;
 
1674
  while(CONVT2(cur_inmd, j)==ggg.kval && j<oE1)
 
1675
    j++;
 
1676
 
 
1677
  ggg.E1 = j;
 
1678
  ggg.total_matchN = ggg.E1 - ggg.S1;
 
1679
  ggg.pg_idx = ggg.S1;
 
1680
 
 
1681
  ggg.more_pg = 0;
 
1682
  if (ggg.total_matchN > page_len()) {
 
1683
    if ((_gtab_space_auto_first & GTAB_space_auto_first_any) || ggg.spc_pressed || pendkey ||
 
1684
      (ggg.ci==cur_inmd->MaxPress && (_gtab_space_auto_first & GTAB_space_auto_first_full)))
 
1685
      ggg.more_pg = 1;
 
1686
  }
 
1687
 
 
1688
  if (ggg.ci < cur_inmd->MaxPress && !ggg.spc_pressed && !pendkey && !ggg.more_pg) {
 
1689
    j = ggg.S1;
 
1690
    ggg.exa_match=0;
 
1691
    clr_seltab();
 
1692
    int match_cnt=0;
 
1693
 
 
1694
    while (CONVT2(cur_inmd, j)==ggg.kval && ggg.exa_match <= page_len()) {
 
1695
      seltab_phrase[ggg.exa_match] = load_seltab(j, ggg.exa_match);
 
1696
      match_cnt++;
 
1697
      ggg.exa_match++;
 
1698
      j++;
 
1699
    }
 
1700
 
 
1701
    ggg.defselN=ggg.exa_match;
 
1702
//    dbg("--- ggg.exa_match %d\n", ggg.exa_match);
 
1703
 
 
1704
    if (ggg.defselN > page_len())
 
1705
      ggg.defselN--;
 
1706
 
 
1707
    int shiftb=(KEY_N - 1 -ggg.ci) * KeyBits;
 
1708
 
 
1709
//    if (gtab_disp_partial_match_on)
 
1710
    while((CONVT2(cur_inmd, j) & vmaskci)==ggg.kval && j<oE1) {
 
1711
      int fff=cur_inmd->keycol[(CONVT2(cur_inmd, j)>>shiftb) & cur_inmd->kmask];
 
1712
      u_char *tbl_ch = tblch(j);
 
1713
 
 
1714
      if (gtab_disp_partial_match_on() && (!seltab[fff][0] || seltab_phrase[fff] ||
 
1715
           (bchcmp(seltab[fff], tbl_ch)>0 && fff > ggg.exa_match))) {
 
1716
        seltab_phrase[fff] = load_seltab(j, fff);
 
1717
        ggg.defselN++;
 
1718
      }
 
1719
 
 
1720
      match_cnt++;
 
1721
#if 0
 
1722
      dbg("jj %d", fff); utf8_putchar(seltab[fff]); dbg("\n");
 
1723
#endif
 
1724
      j++;
 
1725
    }
 
1726
 
 
1727
    if (gtab_unique_auto_send_on()) {
 
1728
      char *first_str=NULL;
 
1729
      for(i=0; i < page_len(); i++) {
 
1730
        if (!seltab[i][0])
 
1731
          continue;
 
1732
        if (!first_str)
 
1733
          first_str = seltab[i];
 
1734
      }
 
1735
 
 
1736
      if (match_cnt==1 && first_str) {
 
1737
        if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
 
1738
          insert_gbuf_nokey(first_str);
 
1739
        else
 
1740
          putstr_inp(first_str);
 
1741
        return 1;
 
1742
      }
 
1743
    }
 
1744
  } else {
 
1745
//    dbg("more %d %d  skip_end:%d\n", ggg.more_pg,  ggg.total_matchN, cur_inmd->flag&FLAG_PHRASE_AUTO_SKIP_ENDKEY);
 
1746
next_pg:
 
1747
    ggg.defselN=0;
 
1748
    clr_seltab();
 
1749
    if (pendkey && (!(cur_inmd->flag&FLAG_PHRASE_AUTO_SKIP_ENDKEY) || !AUTO_SELECT_BY_PHRASE || ggg.ci==1)) {
 
1750
//      dbg("spc_pressed = 1\n");
 
1751
      ggg.spc_pressed = 1;
 
1752
    }
 
1753
 
 
1754
    if (ggg.ci==cur_inmd->MaxPress)
 
1755
      ggg.last_full=1;
 
1756
    int full_send = gtab_press_full_auto_send_on() && ggg.last_full;
 
1757
 
 
1758
//    dbg("flag %d\n",!(pendkey && (cur_inmd->flag&FLAG_PHRASE_AUTO_SKIP_ENDKEY)));
 
1759
    if (AUTO_SELECT_BY_PHRASE && !(pendkey && (cur_inmd->flag&FLAG_PHRASE_AUTO_SKIP_ENDKEY))
 
1760
        && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input &&
 
1761
        (ggg.spc_pressed||full_send)) {
 
1762
      j = ggg.S1;
 
1763
      int selN=0;
 
1764
      char **sel = NULL;
 
1765
 
 
1766
//     puts("kkkkkkkkkkk");
 
1767
      while(j<ggg.E1 && CONVT2(cur_inmd, j)==ggg.kval && selN < 255) {
 
1768
        sel = trealloc(sel, char *, selN+1);
 
1769
        sel[selN++] = load_tblidx(j);
 
1770
        j++;
 
1771
      }
 
1772
      insert_gbuf_cursor(sel, selN, ggg.kval, FALSE);
 
1773
      gtab_scan_pre_select(FALSE);
 
1774
      clear_after_put();
 
1775
      return 1;
 
1776
    } else {
 
1777
      j = ggg.pg_idx;
 
1778
 
 
1779
//      dbg("jjjjjjjjjjjjjjjjjj");
 
1780
      while(j<ggg.E1 && CONVT2(cur_inmd, j)==ggg.kval && ggg.defselN < page_len()) {
 
1781
        load_seltab(j, ggg.defselN);
 
1782
 
 
1783
        j++; ggg.defselN++;
 
1784
 
 
1785
        if (ggg.ci == cur_inmd->MaxPress || ggg.spc_pressed) {
 
1786
          ggg.sel1st_i=0;
 
1787
//          dbg("ggg.sel1st_i %d %d %d\n", ggg.ci, cur_inmd->MaxPress, ggg.spc_pressed);
 
1788
        }
 
1789
      }
 
1790
    }
 
1791
 
 
1792
    ggg.exa_match = ggg.defselN;
 
1793
//    dbg("ggg.defselN %d\n", ggg.defselN);
 
1794
 
 
1795
 
 
1796
    if (ggg.defselN==1 && !ggg.more_pg) {
 
1797
      if (ggg.spc_pressed || full_send || gtab_unique_auto_send_on()) {
 
1798
        if (AUTO_SELECT_BY_PHRASE && poo.same_pho_query_state != SAME_PHO_QUERY_gtab_input)
 
1799
          insert_gbuf_cursor1_cond(seltab[0], ggg.kval, ggg.exa_match);
 
1800
        else
 
1801
          putstr_inp(seltab[0]);
 
1802
        return 1;
 
1803
      }
 
1804
    } else
 
1805
    if (!ggg.defselN) {
 
1806
      bell_err();
 
1807
//      ggg.spc_pressed=0;
 
1808
//      if (gtab_invalid_key_in)
 
1809
      {
 
1810
        ggg.invalid_spc = TRUE;
 
1811
        return TRUE;
 
1812
      }
 
1813
 
 
1814
      return TRUE;
 
1815
    } else
 
1816
    if (!ggg.more_pg) {
 
1817
      if (gtab_dup_select_bell && (gtab_disp_partial_match_on() || gtab_pre_select_or_partial_on())) {
 
1818
        if (ggg.spc_pressed || gtab_full_space_auto_first || (ggg.last_full && gtab_press_full_auto_send_on()))
 
1819
          bell();
 
1820
      }
 
1821
    }
 
1822
  }
 
1823
 
 
1824
Disp_opt:
 
1825
  if (gtab_disp_partial_match_on() || gtab_pre_select_or_partial_on() || ((ggg.exa_match > 1 || ggg.more_pg) &&
 
1826
    (ggg.spc_pressed || gtab_press_full_auto_send_on() ||
 
1827
    (ggg.ci==cur_inmd->MaxPress && (_gtab_space_auto_first & GTAB_space_auto_first_full))) ) ) {
 
1828
       disp_selection(phrase_selected);
 
1829
  }
 
1830
 
 
1831
  return 1;
 
1832
}