← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/hime-setup-list.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/hime-setup-list.c
 
1
/* Copyright (C) 2005-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 "hime.h"
 
19
#include "hime-conf.h"
 
20
#include "gtab.h"
 
21
 
 
22
struct {
 
23
  char *keystr;
 
24
  int keynum;
 
25
} imkeys[] = {
 
26
  {"Control-Space", Control_Space},
 
27
  {"Shift-Space", Shift_Space},
 
28
  {"Alt-Space", Alt_Space},
 
29
  {"Windows-Space", Windows_Space},
 
30
  { NULL, 0},
 
31
};
 
32
 
 
33
extern char *default_input_method_str;
 
34
 
 
35
static GtkWidget *gtablist_window = NULL;
 
36
static GtkWidget *vbox;
 
37
static GtkWidget *hbox;
 
38
static GtkWidget *sw;
 
39
static GtkWidget *treeview;
 
40
static GtkWidget *button, *button2, *check_button_phonetic_speak, *opt_speaker_opts, *check_button_hime_bell_off;
 
41
static GtkWidget *opt_im_toggle_keys, *check_button_hime_remote_client,
 
42
       *check_button_hime_shift_space_eng_full,
 
43
       *check_button_hime_init_im_enabled,
 
44
       *check_button_hime_eng_phrase_enabled,
 
45
       *check_button_hime_win_sym_click_close,
 
46
       *check_button_hime_punc_auto_send;
 
47
 
 
48
static GtkWidget *check_button_hime_single_state;
 
49
extern gboolean button_order;
 
50
 
 
51
char *pho_speaker[16];
 
52
int pho_speakerN;
 
53
 
 
54
typedef struct
 
55
{
 
56
  gchar *name;
 
57
  GdkPixbuf *icon;
 
58
  gchar *key;
 
59
  gchar *file;
 
60
  gboolean cycle;
 
61
  gboolean default_inmd;
 
62
  gboolean use;
 
63
  gboolean editable;
 
64
  INMD *pinmd;
 
65
} Item;
 
66
 
 
67
enum
 
68
{
 
69
  COLUMN_NAME,
 
70
  COLUMN_ICON,
 
71
  COLUMN_KEY,
 
72
  COLUMN_FILE,
 
73
  COLUMN_CYCLE,
 
74
  COLUMN_DEFAULT_INMD,
 
75
  COLUMN_USE,
 
76
  COLUMN_EDITABLE,
 
77
  COLUMN_PINMD,
 
78
  NUM_COLUMNS
 
79
};
 
80
 
 
81
 
 
82
static GArray *articles = NULL;
 
83
int hime_switch_keys_lookup(int key);
 
84
 
 
85
#if 0
 
86
/* unused */
 
87
static int qcmp_key(const void *aa, const void *bb)
 
88
{
 
89
  Item *a=(Item *)aa, *b=(Item *)bb;
 
90
 
 
91
  return hime_switch_keys_lookup(a->key[0]) - hime_switch_keys_lookup(b->key[0]);
 
92
}
 
93
#endif
 
94
 
 
95
extern char *TableDir;
 
96
void get_icon_path(char *iconame, char fname[]);
 
97
 
 
98
static void
 
99
add_items (void)
 
100
{
 
101
  Item foo;
 
102
 
 
103
  g_return_if_fail (articles != NULL);
 
104
 
 
105
  load_gtab_list(FALSE);
 
106
 
 
107
  int i;
 
108
  for (i=0; i < inmdN; i++) {
 
109
    INMD *pinmd = &inmd[i];
 
110
    char *name = pinmd->cname;
 
111
    if (!name)
 
112
      continue;
 
113
 
 
114
    char key[2];
 
115
    char *file = pinmd->filename;
 
116
    char *icon = pinmd->icon;
 
117
 
 
118
    key[0] = pinmd->key_ch;
 
119
    key[1]=0;
 
120
 
 
121
    foo.name = g_strdup(name);
 
122
    char icon_path[128];
 
123
    get_icon_path(icon, icon_path);
 
124
    GError *err = NULL;
 
125
    foo.icon = gdk_pixbuf_new_from_file(icon_path, &err);
 
126
    foo.key = g_strdup(key);
 
127
    foo.file = g_strdup(file);
 
128
//    dbg("%d] %d\n",i,pinmd->in_cycle);
 
129
    foo.default_inmd =  default_input_method == i;
 
130
    foo.use = !pinmd->disabled;
 
131
    foo.cycle = pinmd->in_cycle && foo.use;
 
132
    foo.editable = FALSE;
 
133
    foo.pinmd = pinmd;
 
134
    g_array_append_vals (articles, &foo, 1);
 
135
  }
 
136
 
 
137
//  g_array_sort (articles,qcmp_key);
 
138
}
 
139
 
 
140
static GtkTreeModel *
 
141
create_model (void)
 
142
{
 
143
  gint i = 0;
 
144
  GtkListStore *model;
 
145
  GtkTreeIter iter;
 
146
 
 
147
  /* create array */
 
148
  articles = g_array_sized_new (FALSE, FALSE, sizeof (Item), 1);
 
149
 
 
150
  add_items ();
 
151
 
 
152
  /* create list store */
 
153
  model = gtk_list_store_new (NUM_COLUMNS,G_TYPE_STRING, GDK_TYPE_PIXBUF,
 
154
                              G_TYPE_STRING,
 
155
                              G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
 
156
                              G_TYPE_BOOLEAN,
 
157
                              G_TYPE_BOOLEAN, G_TYPE_POINTER);
 
158
 
 
159
  /* add items */
 
160
  for (i = 0; i < articles->len; i++) {
 
161
      gtk_list_store_append (model, &iter);
 
162
 
 
163
      gtk_list_store_set (model, &iter,
 
164
                          COLUMN_NAME,
 
165
                          g_array_index (articles, Item, i).name,
 
166
                          COLUMN_ICON,
 
167
                          g_array_index (articles, Item, i).icon,
 
168
                          COLUMN_KEY,
 
169
                          g_array_index (articles, Item, i).key,
 
170
                          COLUMN_FILE,
 
171
                          g_array_index (articles, Item, i).file,
 
172
                          COLUMN_CYCLE,
 
173
                          g_array_index (articles, Item, i).cycle,
 
174
                          COLUMN_DEFAULT_INMD,
 
175
                          g_array_index (articles, Item, i).default_inmd,
 
176
                          COLUMN_USE,
 
177
                          g_array_index (articles, Item, i).use,
 
178
                          COLUMN_EDITABLE,
 
179
                          g_array_index (articles, Item, i).editable,
 
180
                          COLUMN_PINMD,
 
181
                          g_array_index (articles, Item, i).pinmd,
 
182
                          -1);
 
183
  }
 
184
 
 
185
  return GTK_TREE_MODEL (model);
 
186
}
 
187
 
 
188
 
 
189
extern char gtab_list[];
 
190
 
 
191
static void save_gtab_list()
 
192
{
 
193
  char ttt[128];
 
194
  get_hime_user_fname(gtab_list, ttt);
 
195
 
 
196
  FILE *fp;
 
197
 
 
198
  if ((fp=fopen(ttt, "w"))==NULL)
 
199
    p_err("cannot write to %s\n", ttt);
 
200
 
 
201
  int i;
 
202
  for (i=0; i < inmdN; i++) {
 
203
    INMD *pinmd = &inmd[i];
 
204
    char *name = pinmd->cname;
 
205
    if (!name)
 
206
      continue;
 
207
 
 
208
    char *file = pinmd->filename;
 
209
    char *icon = pinmd->icon;
 
210
    char *disabled = pinmd->disabled?"!":"";
 
211
 
 
212
    fprintf(fp, "%s%s %c %s %s\n", disabled,name, pinmd->key_ch, file, icon);
 
213
  }
 
214
 
 
215
  fclose(fp);
 
216
}
 
217
 
 
218
 
 
219
static void cb_ok (GtkWidget *button, gpointer data)
 
220
{
 
221
  GtkTreeModel *model = GTK_TREE_MODEL (data);
 
222
 
 
223
  GtkTreeIter iter;
 
224
  if (!gtk_tree_model_get_iter_first(model, &iter))
 
225
    return;
 
226
 
 
227
  do {
 
228
    char *tkey;
 
229
    gtk_tree_model_get(model,&iter, COLUMN_KEY, &tkey, -1);
 
230
    gboolean cycle, default_inmd, use;
 
231
    gtk_tree_model_get (model, &iter, COLUMN_CYCLE, &cycle, -1);
 
232
    gtk_tree_model_get (model, &iter, COLUMN_DEFAULT_INMD, &default_inmd, -1);
 
233
    gtk_tree_model_get (model, &iter, COLUMN_USE, &use, -1);
 
234
    INMD *pinmd;
 
235
    gtk_tree_model_get (model, &iter, COLUMN_PINMD, &pinmd, -1);
 
236
    pinmd->in_cycle = cycle;
 
237
    pinmd->disabled = !use;
 
238
  } while (gtk_tree_model_iter_next(model, &iter));
 
239
 
 
240
  dbg("default_input_method_str %s\n",default_input_method_str);
 
241
  save_hime_conf_str(DEFAULT_INPUT_METHOD, default_input_method_str);
 
242
 
 
243
  int idx;
 
244
  idx = gtk_combo_box_get_active (GTK_COMBO_BOX (opt_im_toggle_keys));
 
245
  save_hime_conf_int(HIME_IM_TOGGLE_KEYS, imkeys[idx].keynum);
 
246
 
 
247
  free(hime_str_im_cycle);
 
248
 
 
249
  int i;
 
250
  char tt[512];
 
251
  int ttN=0;
 
252
  for(i=0;i<inmdN;i++) {
 
253
    if (inmd[i].in_cycle) {
 
254
      dbg("in %d %c\n", i, inmd[i].key_ch);
 
255
      tt[ttN++]=inmd[i].key_ch;
 
256
    }
 
257
  }
 
258
  tt[ttN]=0;
 
259
  hime_str_im_cycle = strdup(tt);
 
260
  save_hime_conf_str(HIME_STR_IM_CYCLE, hime_str_im_cycle);
 
261
  dbg("hime_str_im_cycle ttN:%d '%s' '%s'\n", ttN, hime_str_im_cycle, tt);
 
262
 
 
263
  save_hime_conf_int(HIME_REMOTE_CLIENT,
 
264
    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_remote_client)));
 
265
  save_hime_conf_int(HIME_SHIFT_SPACE_ENG_FULL,
 
266
    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_shift_space_eng_full)));
 
267
 
 
268
  save_hime_conf_int(HIME_INIT_IM_ENABLED,
 
269
    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_init_im_enabled)));
 
270
 
 
271
  save_hime_conf_int(HIME_ENG_PHRASE_ENABLED,
 
272
    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_eng_phrase_enabled)));
 
273
 
 
274
  save_hime_conf_int(HIME_WIN_SYM_CLICK_CLOSE,
 
275
    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_win_sym_click_close)));
 
276
 
 
277
  save_hime_conf_int(HIME_BELL_OFF,
 
278
    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_bell_off)));
 
279
 
 
280
  save_hime_conf_int(HIME_PUNC_AUTO_SEND,
 
281
    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_punc_auto_send)));
 
282
  save_hime_conf_int(HIME_SINGLE_STATE,
 
283
    gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_hime_single_state)));
 
284
  if (opt_speaker_opts) {
 
285
    idx = gtk_combo_box_get_active (GTK_COMBO_BOX (opt_speaker_opts));
 
286
    save_hime_conf_str(PHONETIC_SPEAK_SEL, pho_speaker[idx]);
 
287
  }
 
288
 
 
289
  save_gtab_list();
 
290
 
 
291
  save_hime_conf_int(PHONETIC_SPEAK,
 
292
     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button_phonetic_speak)));
 
293
 
 
294
  gtk_widget_destroy(gtablist_window); gtablist_window = NULL;
 
295
 
 
296
  /* caleb- does found where "reload" is used.
 
297
   * caleb- think the send_hime_message() here does nothing.
 
298
   */
 
299
  send_hime_message(GDK_DISPLAY(), "reload");
 
300
}
 
301
 
 
302
static void cb_cancel (GtkWidget *widget, gpointer data)
 
303
{
 
304
  gtk_widget_destroy(gtablist_window); gtablist_window = NULL;
 
305
}
 
306
 
 
307
int hime_switch_keys_lookup(int key);
 
308
#if 1
 
309
static gboolean toggled (GtkCellRendererToggle *cell, gchar *path_string, gpointer data)
 
310
{
 
311
  GtkTreeModel *model = GTK_TREE_MODEL (data);
 
312
  GtkTreeIter iter;
 
313
  GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
 
314
  gboolean cycle;
 
315
 
 
316
  dbg("toggled\n");
 
317
 
 
318
  gtk_tree_model_get_iter (model, &iter, path);
 
319
  gtk_tree_model_get (model, &iter, COLUMN_CYCLE, &cycle, -1);
 
320
 
 
321
  cycle ^= 1;
 
322
  gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_CYCLE, cycle, -1);
 
323
 
 
324
  if (cycle) {
 
325
    gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_USE, TRUE, -1);
 
326
  }
 
327
 
 
328
  gtk_tree_path_free (path);
 
329
 
 
330
  return TRUE;
 
331
}
 
332
#endif
 
333
 
 
334
static void clear_col_default_inmd(GtkTreeModel *model)
 
335
{
 
336
  GtkTreeIter iter;
 
337
 
 
338
  if (!gtk_tree_model_get_iter_first(model, &iter))
 
339
    return;
 
340
 
 
341
  do {
 
342
    char *tkey;
 
343
    gtk_tree_model_get(model,&iter, COLUMN_KEY, &tkey, -1);
 
344
    gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_DEFAULT_INMD, 0, -1);
 
345
 
 
346
  } while (gtk_tree_model_iter_next(model, &iter));
 
347
}
 
348
 
 
349
 
 
350
static gboolean toggled_default_inmd(GtkCellRendererToggle *cell, gchar *path_string, gpointer data)
 
351
{
 
352
  GtkTreeModel *model = GTK_TREE_MODEL (data);
 
353
  clear_col_default_inmd(model);
 
354
  GtkTreeIter iter;
 
355
  GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
 
356
 
 
357
//  dbg("toggled_default_inmd\n");
 
358
  gtk_tree_model_get_iter (model, &iter, path);
 
359
  char *key;
 
360
  gtk_tree_model_get (model, &iter, COLUMN_KEY, &key, -1);
 
361
  char *file;
 
362
  gtk_tree_model_get (model, &iter, COLUMN_FILE, &file, -1);
 
363
  char tt[128];
 
364
  sprintf(tt, "%s %s", key, file);
 
365
  free(default_input_method_str);
 
366
  default_input_method_str = strdup(tt);
 
367
  dbg("default_input_method_str %s\n", default_input_method_str);
 
368
//  default_input_method = hime_switch_keys_lookup(key[0]);
 
369
 
 
370
  gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_DEFAULT_INMD, TRUE, -1);
 
371
  gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_USE, TRUE, -1);
 
372
 
 
373
  gtk_tree_path_free (path);
 
374
 
 
375
  return TRUE;
 
376
}
 
377
 
 
378
static gboolean toggled_use(GtkCellRendererToggle *cell, gchar *path_string, gpointer data)
 
379
{
 
380
  GtkTreeModel *model = GTK_TREE_MODEL (data);
 
381
//  clear_all(model);
 
382
  GtkTreeIter iter;
 
383
  GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
 
384
 
 
385
//  dbg("toggled_default_inmd\n");
 
386
  gtk_tree_model_get_iter (model, &iter, path);
 
387
  gboolean cycle, default_inmd, use;
 
388
  gtk_tree_model_get (model, &iter, COLUMN_CYCLE, &cycle, -1);
 
389
  gtk_tree_model_get (model, &iter, COLUMN_DEFAULT_INMD, &default_inmd, -1);
 
390
  gtk_tree_model_get (model, &iter, COLUMN_USE, &use, -1);
 
391
  use=!use;
 
392
  gboolean must_on = default_inmd;
 
393
  dbg("toggle %d %d %d\n", cycle, default_inmd, use);
 
394
 
 
395
  if (must_on && !use) {
 
396
    return TRUE;
 
397
  }
 
398
 
 
399
  gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_USE, use, -1);
 
400
  if (!use)
 
401
    gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_CYCLE, FALSE, -1);
 
402
 
 
403
  gtk_tree_path_free (path);
 
404
 
 
405
  return TRUE;
 
406
}
 
407
 
 
408
 
 
409
static void
 
410
add_columns (GtkTreeView *treeview)
 
411
{
 
412
  GtkCellRenderer *renderer;
 
413
  GtkTreeModel *model = gtk_tree_view_get_model (treeview);
 
414
 
 
415
  /* name column */
 
416
 
 
417
  renderer = gtk_cell_renderer_text_new ();
 
418
  g_object_set_data (G_OBJECT (renderer), "column", (gint *)COLUMN_NAME);
 
419
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 
420
                                               -1, _("名稱"), renderer,
 
421
                                               "text", COLUMN_NAME,
 
422
                                               "editable", COLUMN_EDITABLE,
 
423
                                               NULL);
 
424
 
 
425
  renderer = gtk_cell_renderer_pixbuf_new();
 
426
  g_object_set_data (G_OBJECT (renderer), "column", (gint *)COLUMN_ICON);
 
427
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 
428
                                               -1, "圖示", renderer,
 
429
                                               "pixbuf", COLUMN_ICON,
 
430
//                                               "editable", COLUMN_EDITABLE,
 
431
                                               NULL);
 
432
 
 
433
  renderer = gtk_cell_renderer_text_new ();
 
434
  g_object_set_data (G_OBJECT (renderer), "column", (gint *)COLUMN_KEY);
 
435
 
 
436
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 
437
                                               -1, _("Ctrl-Alt-鍵"), renderer,
 
438
                                               "text", COLUMN_KEY,
 
439
                                               "editable", COLUMN_EDITABLE,
 
440
                                               NULL);
 
441
 
 
442
  // cycle column
 
443
  renderer = gtk_cell_renderer_toggle_new ();
 
444
  g_signal_connect (G_OBJECT (renderer), "toggled",
 
445
                    G_CALLBACK (toggled), model);
 
446
 
 
447
  g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
 
448
 
 
449
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),-1,
 
450
          _("在 Ctrl-Shift 中循環"),
 
451
          renderer, "active", COLUMN_CYCLE,
 
452
                                               NULL);
 
453
 
 
454
  // default_inmd column
 
455
  renderer = gtk_cell_renderer_toggle_new ();
 
456
  gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(renderer), TRUE);
 
457
  g_signal_connect (G_OBJECT (renderer), "toggled",
 
458
                    G_CALLBACK (toggled_default_inmd), model);
 
459
 
 
460
  g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
 
461
 
 
462
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 
463
                                               -1, _("預設"),
 
464
 
 
465
                                               renderer,
 
466
                                               "active", COLUMN_DEFAULT_INMD,
 
467
                                               NULL);
 
468
 
 
469
  // use
 
470
  renderer = gtk_cell_renderer_toggle_new ();
 
471
  g_signal_connect (G_OBJECT (renderer), "toggled",
 
472
                    G_CALLBACK (toggled_use), model);
 
473
 
 
474
  g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
 
475
 
 
476
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 
477
                                               -1, _("啟用"),
 
478
                                               renderer,
 
479
                                               "active", COLUMN_USE,
 
480
                                               NULL);
 
481
 
 
482
  renderer = gtk_cell_renderer_text_new ();
 
483
  g_object_set_data (G_OBJECT (renderer), "column", (gint *)COLUMN_FILE);
 
484
 
 
485
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 
486
                                               -1, _("檔案名稱"), renderer,
 
487
                                               "text", COLUMN_FILE,
 
488
                                               "editable", COLUMN_EDITABLE,
 
489
                                               NULL);
 
490
}
 
491
 
 
492
 
 
493
static void callback_win_delete()
 
494
{
 
495
  gtk_widget_destroy(gtablist_window); gtablist_window = NULL;
 
496
}
 
497
 
 
498
void set_selection_by_key(int key)
 
499
{
 
500
  if (!treeview)
 
501
    return;
 
502
 
 
503
  GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
 
504
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
 
505
  GtkTreeIter iter;
 
506
  gboolean found=FALSE;
 
507
 
 
508
  if (!gtk_tree_model_get_iter_first(model, &iter))
 
509
    return;
 
510
 
 
511
  do {
 
512
    char *tkey;
 
513
 
 
514
    gtk_tree_model_get(model,&iter, COLUMN_KEY, &tkey,-1);
 
515
 
 
516
    if (atoi(tkey) == key) {
 
517
      found=TRUE;
 
518
      break;
 
519
    }
 
520
  } while (gtk_tree_model_iter_next(model, &iter));
 
521
 
 
522
  if (found)
 
523
    gtk_tree_selection_select_iter(selection,&iter);
 
524
}
 
525
 
 
526
static GtkWidget *create_im_toggle_keys()
 
527
{
 
528
 
 
529
  GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
 
530
  GtkWidget *label = gtk_label_new(_("輸入視窗(開啟/關閉)切換"));
 
531
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
532
 
 
533
  opt_im_toggle_keys = gtk_combo_box_new_text ();
 
534
  gtk_box_pack_start (GTK_BOX (hbox), opt_im_toggle_keys, FALSE, FALSE, 0);
 
535
 
 
536
  int i, current_idx=0;
 
537
 
 
538
  for(i=0; imkeys[i].keystr; i++) {
 
539
    if (imkeys[i].keynum == hime_im_toggle_keys)
 
540
      current_idx = i;
 
541
    gtk_combo_box_append_text (GTK_COMBO_BOX_TEXT (opt_im_toggle_keys), imkeys[i].keystr);
 
542
  }
 
543
 
 
544
  gtk_combo_box_set_active (GTK_COMBO_BOX (opt_im_toggle_keys), current_idx);
 
545
 
 
546
  return hbox;
 
547
}
 
548
 
 
549
int get_current_speaker_idx();
 
550
 
 
551
static GtkWidget *create_speaker_opts()
 
552
{
 
553
  GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
 
554
 
 
555
  opt_speaker_opts = gtk_combo_box_new_text ();
 
556
  gtk_box_pack_start (GTK_BOX (hbox), opt_speaker_opts, FALSE, FALSE, 0);
 
557
 
 
558
  int i;
 
559
  int current_idx = get_current_speaker_idx();
 
560
 
 
561
  for(i=0; i<pho_speakerN; i++) {
 
562
    if (imkeys[i].keynum == hime_im_toggle_keys)
 
563
      current_idx = i;
 
564
    gtk_combo_box_append_text (GTK_COMBO_BOX_TEXT (opt_speaker_opts), pho_speaker[i]);
 
565
  }
 
566
 
 
567
  gtk_combo_box_set_active (GTK_COMBO_BOX (opt_speaker_opts), current_idx);
 
568
 
 
569
  return hbox;
 
570
}
 
571
 
 
572
#include <dirent.h>
 
573
 
 
574
void create_gtablist_window (void)
 
575
{
 
576
  if (gtablist_window) {
 
577
    gtk_window_present(GTK_WINDOW(gtablist_window));
 
578
    return;
 
579
  }
 
580
 
 
581
  /* create gtab_list_window, etc */
 
582
  gtablist_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
583
  gtk_window_set_position(GTK_WINDOW(gtablist_window), GTK_WIN_POS_MOUSE);
 
584
 
 
585
  gtk_window_set_has_resize_grip(GTK_WINDOW(gtablist_window), FALSE);
 
586
 gtk_window_set_title (GTK_WINDOW (gtablist_window), _("輸入法選擇"));
 
587
  gtk_container_set_border_width (GTK_CONTAINER (gtablist_window), 1);
 
588
 
 
589
  g_signal_connect (G_OBJECT (gtablist_window), "destroy",
 
590
                    G_CALLBACK (gtk_widget_destroyed), &gtablist_window);
 
591
 
 
592
  g_signal_connect (G_OBJECT (gtablist_window), "delete_event",
 
593
                      G_CALLBACK (callback_win_delete), NULL);
 
594
 
 
595
  vbox = gtk_vbox_new (FALSE, 0);
 
596
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
 
597
  gtk_container_add (GTK_CONTAINER (gtablist_window), vbox);
 
598
 
 
599
  sw = gtk_scrolled_window_new (NULL, NULL);
 
600
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
 
601
                                       GTK_SHADOW_ETCHED_IN);
 
602
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 
603
                                  GTK_POLICY_AUTOMATIC,
 
604
                                  GTK_POLICY_AUTOMATIC);
 
605
  gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
 
606
 
 
607
  /* create model */
 
608
  GtkTreeModel *model = create_model ();
 
609
 
 
610
  /* create tree view */
 
611
  treeview = gtk_tree_view_new_with_model (model);
 
612
  gtk_widget_set_hexpand (treeview, TRUE);
 
613
  gtk_widget_set_vexpand (treeview, TRUE);
 
614
  g_object_unref (G_OBJECT (model));
 
615
  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
 
616
 
 
617
  GtkTreeSelection *tree_selection =
 
618
     gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
 
619
  gtk_tree_selection_set_mode (tree_selection, GTK_SELECTION_SINGLE);
 
620
 
 
621
  add_columns (GTK_TREE_VIEW (treeview));
 
622
 
 
623
  gtk_container_add (GTK_CONTAINER (sw), treeview);
 
624
 
 
625
  gtk_box_pack_start (GTK_BOX (vbox), create_im_toggle_keys(), FALSE, FALSE, 0);
 
626
 
 
627
  GtkWidget *hbox_hime_remote_client = gtk_hbox_new (FALSE, 10);
 
628
  gtk_box_pack_start (GTK_BOX (vbox), hbox_hime_remote_client, FALSE, FALSE, 0);
 
629
  check_button_hime_remote_client = gtk_check_button_new_with_label (_("支援遠端用戶端程式 (port 9999-)"));
 
630
  gtk_box_pack_start (GTK_BOX (hbox_hime_remote_client),check_button_hime_remote_client,  FALSE, FALSE, 0);
 
631
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_remote_client),
 
632
     hime_remote_client);
 
633
 
 
634
 
 
635
  GtkWidget *hbox_hime_init_im_enabled = gtk_hbox_new (FALSE, 10);
 
636
  gtk_box_pack_start (GTK_BOX (vbox), hbox_hime_init_im_enabled, FALSE, FALSE, 0);
 
637
  check_button_hime_init_im_enabled = gtk_check_button_new_with_label (_("直接進入中文輸入狀態 (限非XIM)"));
 
638
  gtk_box_pack_start (GTK_BOX (hbox_hime_init_im_enabled),check_button_hime_init_im_enabled,  FALSE, FALSE, 0);
 
639
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_init_im_enabled),
 
640
     hime_init_im_enabled);
 
641
 
 
642
  GtkWidget *hbox_hime_shift_space_eng_full = gtk_hbox_new (FALSE, 10);
 
643
  gtk_box_pack_start (GTK_BOX (vbox), hbox_hime_shift_space_eng_full, FALSE, FALSE, 0);
 
644
  check_button_hime_shift_space_eng_full = gtk_check_button_new_with_label (_("按下 shift-space 進入全形英文模式"));
 
645
  gtk_box_pack_start (GTK_BOX (hbox_hime_shift_space_eng_full),check_button_hime_shift_space_eng_full,  FALSE, FALSE, 0);
 
646
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_shift_space_eng_full),
 
647
     hime_shift_space_eng_full);
 
648
 
 
649
  GtkWidget *hbox_hime_single_state = gtk_hbox_new (FALSE, 10);
 
650
  gtk_box_pack_start (GTK_BOX (vbox), hbox_hime_single_state, FALSE, FALSE, 0);
 
651
  check_button_hime_single_state = gtk_check_button_new_with_label (_("所有程式共用相同的輸入法狀態"));
 
652
  gtk_box_pack_start (GTK_BOX (hbox_hime_single_state),check_button_hime_single_state,  FALSE, FALSE, 0);
 
653
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_single_state),
 
654
     hime_single_state);
 
655
 
 
656
  GtkWidget *hbox_hime_eng_phrase_enabled = gtk_hbox_new (FALSE, 10);
 
657
  gtk_box_pack_start (GTK_BOX (vbox), hbox_hime_eng_phrase_enabled, FALSE, FALSE, 0);
 
658
  check_button_hime_eng_phrase_enabled = gtk_check_button_new_with_label (_("英數狀態下可使用 alt-shift 片語"));
 
659
  gtk_box_pack_start (GTK_BOX (hbox_hime_eng_phrase_enabled),check_button_hime_eng_phrase_enabled,  FALSE, FALSE, 0);
 
660
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_eng_phrase_enabled),
 
661
     hime_eng_phrase_enabled);
 
662
 
 
663
  GtkWidget *hbox_phonetic_speak = gtk_hbox_new(FALSE, 10);
 
664
  gtk_box_pack_start (GTK_BOX (vbox), hbox_phonetic_speak , FALSE, FALSE, 0);
 
665
  check_button_phonetic_speak = gtk_check_button_new_with_label (_("輸入的同時念出發音"));
 
666
  gtk_box_pack_start (GTK_BOX (hbox_phonetic_speak), check_button_phonetic_speak, FALSE, FALSE, 0);
 
667
  gtk_toggle_button_set_active(
 
668
     GTK_TOGGLE_BUTTON(check_button_phonetic_speak), phonetic_speak);
 
669
 
 
670
 
 
671
  GtkWidget *hbox_hime_win_sym_click_close = gtk_hbox_new (FALSE, 10);
 
672
  gtk_box_pack_start (GTK_BOX (vbox), hbox_hime_win_sym_click_close, FALSE, FALSE, 0);
 
673
  check_button_hime_win_sym_click_close = gtk_check_button_new_with_label (_("符號視窗點選後自動關閉"));
 
674
  gtk_box_pack_start (GTK_BOX (hbox_hime_win_sym_click_close),check_button_hime_win_sym_click_close,  FALSE, FALSE, 0);
 
675
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_win_sym_click_close),
 
676
     hime_win_sym_click_close);
 
677
 
 
678
  GtkWidget *hbox_hime_bell_off = gtk_hbox_new (FALSE, 10);
 
679
  gtk_box_pack_start (GTK_BOX (vbox), hbox_hime_bell_off, FALSE, FALSE, 0);
 
680
  check_button_hime_bell_off = gtk_check_button_new_with_label (_("關閉嗶聲"));
 
681
  gtk_box_pack_start (GTK_BOX (hbox_hime_bell_off),check_button_hime_bell_off,  FALSE, FALSE, 0);
 
682
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_bell_off),
 
683
     hime_bell_off);
 
684
 
 
685
  GtkWidget *hbox_hime_punc_auto_send = gtk_hbox_new (FALSE, 10);
 
686
  gtk_box_pack_start (GTK_BOX (vbox), hbox_hime_punc_auto_send, FALSE, FALSE, 0);
 
687
  check_button_hime_punc_auto_send = gtk_check_button_new_with_label (_("結尾標點符號自動送出編輯區內容"));
 
688
  gtk_box_pack_start (GTK_BOX (hbox_hime_punc_auto_send),check_button_hime_punc_auto_send,  FALSE, FALSE, 0);
 
689
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_punc_auto_send),
 
690
     hime_punc_auto_send);
 
691
 
 
692
  DIR *dir;
 
693
  if ((dir=opendir(HIME_OGG_DIR"/ㄧ"))) {
 
694
    struct dirent *dire;
 
695
 
 
696
    pho_speakerN = 0;
 
697
    while ((dire=readdir(dir))) {
 
698
      char *name = dire->d_name;
 
699
 
 
700
      if (name[0]=='.')
 
701
        continue;
 
702
      pho_speaker[pho_speakerN++]=strdup(name);
 
703
    }
 
704
    closedir(dir);
 
705
 
 
706
    dbg("pho_speakerN:%d\n", pho_speakerN);
 
707
 
 
708
  }
 
709
 
 
710
  if (pho_speakerN) {
 
711
    GtkWidget *labelspeaker = gtk_label_new(_("發音選擇"));
 
712
    gtk_box_pack_start (GTK_BOX (hbox_phonetic_speak), labelspeaker, FALSE, FALSE, 0);
 
713
    gtk_container_add (GTK_CONTAINER (hbox_phonetic_speak), create_speaker_opts());
 
714
  }
 
715
 
 
716
  hbox = gtk_hbox_new (TRUE, 4);
 
717
  gtk_grid_set_column_homogeneous(GTK_GRID(hbox), TRUE);
 
718
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
719
 
 
720
  button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
 
721
  g_signal_connect (G_OBJECT (button), "clicked",
 
722
                    G_CALLBACK (cb_cancel), treeview);
 
723
  if (button_order)
 
724
    gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
 
725
  else
 
726
    gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
 
727
 
 
728
  button2 = gtk_button_new_from_stock (GTK_STOCK_OK);
 
729
  g_signal_connect (G_OBJECT (button2), "clicked",
 
730
                    G_CALLBACK (cb_ok), model);
 
731
#if !GTK_CHECK_VERSION(2,91,2)
 
732
  if (button_order)
 
733
    gtk_box_pack_end (GTK_BOX (hbox), button2, TRUE, TRUE, 0);
 
734
  else
 
735
    gtk_box_pack_start (GTK_BOX (hbox), button2, TRUE, TRUE, 0);
 
736
#else
 
737
  if (button_order)
 
738
    gtk_grid_attach_next_to (GTK_BOX (hbox), button2, button, GTK_POS_LEFT, 1, 1);
 
739
  else
 
740
    gtk_grid_attach_next_to (GTK_BOX (hbox), button2, button, GTK_POS_RIGHT, 1, 1);
 
741
#endif
 
742
  gtk_window_set_default_size (GTK_WINDOW (gtablist_window), 620, 450);
 
743
 
 
744
  g_signal_connect (G_OBJECT (gtablist_window), "delete_event",
 
745
                    G_CALLBACK (gtk_main_quit), NULL);
 
746
 
 
747
  gtk_widget_show_all (gtablist_window);
 
748
 
 
749
  set_selection_by_key(default_input_method);
 
750
 
 
751
#if 0
 
752
  g_signal_connect (G_OBJECT(tree_selection), "changed",
 
753
                    G_CALLBACK (callback_row_selected), NULL);
 
754
#endif
 
755
}