← Back to branch summary

~ubuntu-branches/ubuntu/maverick/uim/maverick

« back to all changes in this revision

Viewing changes to helper/pref-gtk.c

  • Committer: Bazaar Package Importer
  • Author(s): Masahito Omote
  • Date: 2006-11-23 15:10:53 UTC
  • mfrom: (3.1.8 edgy)
  • Revision ID: james.westby@ubuntu.com-20061123151053-q42sk1lvks41xpfx
Tags: 1:1.2.1-9
http://bugs.debian.org/398530
uim-gtk2.0.postinst: Don't call update-gtk-immodules on purge.
(closes: Bug#398530)

Show diffs side-by-side

added added

removed removed

Lines of Context:
helper/pref-gtk.c
 
1
/*
 
2
 
 
3
  Copyright (c) 2005-2006 uim Project http://uim.freedesktop.org/
 
4
 
 
5
  All rights reserved.
 
6
 
 
7
  Redistribution and use in source and binary forms, with or without
 
8
  modification, are permitted provided that the following conditions
 
9
  are met:
 
10
 
 
11
  1. Redistributions of source code must retain the above copyright
 
12
     notice, this list of conditions and the following disclaimer.
 
13
  2. Redistributions in binary form must reproduce the above copyright
 
14
     notice, this list of conditions and the following disclaimer in the
 
15
     documentation and/or other materials provided with the distribution.
 
16
  3. Neither the name of authors nor the names of its contributors
 
17
     may be used to endorse or promote products derived from this software
 
18
     without specific prior written permission.
 
19
 
 
20
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
 
21
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
22
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
23
  ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
 
24
  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
25
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
26
  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
27
  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
28
  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 
29
  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 
30
  SUCH DAMAGE.
 
31
 
 
32
*/
 
33
 
 
34
#include <config.h>
 
35
 
 
36
#include <glib.h>
 
37
#include <gdk/gdkkeysyms.h>
 
38
 
 
39
#include <string.h>
 
40
#include <stdlib.h>
 
41
#include <locale.h>
 
42
 
 
43
#include "uim/uim.h"
 
44
#include "uim/uim-custom.h"
 
45
#include "uim/gettext.h"
 
46
#include "pref-gtk-custom-widgets.h"
 
47
#include "../gtk/key-util-gtk.h"
 
48
 
 
49
#define DEFAULT_WINDOW_WIDTH_MAX 800
 
50
#define DEFAULT_WINDOW_HEIGHT_MAX 600
 
51
#define USE_CHANGES_SENSITIVE_OK_BUTTON 0
 
52
 
 
53
static GtkWidget *pref_window = NULL;
 
54
static GtkWidget *pref_tree_view = NULL;
 
55
static GtkWidget *pref_hbox = NULL;
 
56
static GtkWidget *current_group_widget = NULL;
 
57
 
 
58
gboolean uim_pref_gtk_value_changed = FALSE;
 
59
static GtkWidget *pref_apply_button = NULL;
 
60
static GtkWidget *pref_ok_button = NULL;
 
61
 
 
62
enum
 
63
{
 
64
  GROUP_COLUMN=0,
 
65
  GROUP_WIDGET=1,
 
66
  NUM_COLUMNS
 
67
};
 
68
 
 
69
void uim_pref_gtk_mark_value_changed(void);
 
70
void uim_pref_gtk_unmark_value_changed(void);
 
71
 
 
72
static gboolean pref_tree_selection_changed(GtkTreeSelection *selection,
 
73
                                             gpointer data);
 
74
static GtkWidget *create_pref_treeview(void);
 
75
static GtkWidget *create_group_widget(const char *group_name);
 
76
static void create_sub_group_widgets(GtkWidget *parent_widget,
 
77
                                     const char *parent_group);
 
78
 
 
79
void
 
80
uim_pref_gtk_mark_value_changed(void)
 
81
{
 
82
  uim_pref_gtk_value_changed = TRUE;
 
83
  gtk_widget_set_sensitive(pref_apply_button, TRUE);
 
84
#if USE_CHANGES_SENSITIVE_OK_BUTTON
 
85
  gtk_widget_set_sensitive(pref_ok_button, TRUE);
 
86
#endif
 
87
}
 
88
 
 
89
void
 
90
uim_pref_gtk_unmark_value_changed(void)
 
91
{
 
92
  uim_pref_gtk_value_changed = FALSE;
 
93
  gtk_widget_set_sensitive(pref_apply_button, FALSE);
 
94
#if USE_CHANGES_SENSITIVE_OK_BUTTON
 
95
  gtk_widget_set_sensitive(pref_ok_button, FALSE);
 
96
#endif
 
97
}
 
98
 
 
99
/*
 
100
 *  2005-02-10 Takuro Ashie <ashie@homa.ne.jp>
 
101
 *    This feature is disabled according to [Anthy-dev 1795].
 
102
 */
 
103
#if 0
 
104
static void
 
105
save_confirm_dialog_response_cb(GtkDialog *dialog, gint arg, gpointer user_data)
 
106
{
 
107
  switch (arg)
 
108
  {
 
109
  case GTK_RESPONSE_YES:
 
110
    uim_custom_save();
 
111
    uim_custom_broadcast();
 
112
    uim_pref_gtk_value_changed = FALSE;
 
113
    break;
 
114
  case GTK_RESPONSE_NO:
 
115
    uim_pref_gtk_value_changed = FALSE;
 
116
    break;
 
117
  default:
 
118
    break;
 
119
  }
 
120
}
 
121
#endif
 
122
 
 
123
static gboolean
 
124
pref_tree_selection_changed(GtkTreeSelection *selection,
 
125
                             gpointer data)
 
126
{
 
127
  GtkTreeStore *store;
 
128
  GtkTreeIter iter;
 
129
  GtkTreeModel *model;
 
130
  char *group_name;
 
131
  GtkWidget *group_widget;
 
132
 
 
133
/*
 
134
 *  2005-02-10 Takuro Ashie <ashie@homa.ne.jp>
 
135
 *    This feature is disabled according to [Anthy-dev 1795].
 
136
 */
 
137
#if 0
 
138
  /* Preference save check should be here. */
 
139
  if (uim_pref_gtk_value_changed) {
 
140
    GtkWidget *dialog;
 
141
    dialog = gtk_message_dialog_new(NULL,
 
142
                                    GTK_DIALOG_MODAL,
 
143
                                    GTK_MESSAGE_QUESTION,
 
144
                                    GTK_BUTTONS_YES_NO,
 
145
                                    _("Some value(s) have been changed.\n"
 
146
                                      "Save?"));
 
147
    gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(pref_window));
 
148
    gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
 
149
    g_signal_connect(G_OBJECT(dialog), "response",
 
150
                     G_CALLBACK(save_confirm_dialog_response_cb), NULL);
 
151
    gtk_dialog_run(GTK_DIALOG(dialog));
 
152
    gtk_widget_destroy(dialog);
 
153
  }
 
154
#endif
 
155
 
 
156
  if (gtk_tree_selection_get_selected(selection, &model, &iter) == FALSE)
 
157
    return TRUE;
 
158
 
 
159
  store = GTK_TREE_STORE(model);
 
160
  gtk_tree_model_get(model, &iter,
 
161
                     GROUP_COLUMN, &group_name,
 
162
                     GROUP_WIDGET, &group_widget,
 
163
                     -1);
 
164
 
 
165
  if (group_name == NULL)
 
166
    return TRUE;
 
167
 
 
168
  /* hide current selected group's widget */
 
169
  if (current_group_widget)
 
170
    gtk_widget_hide(current_group_widget);
 
171
 
 
172
  /* whether group_widget is already packed or not */
 
173
  if (!gtk_widget_get_parent(group_widget))
 
174
    gtk_box_pack_start (GTK_BOX (pref_hbox), group_widget, TRUE, TRUE, 0);
 
175
 
 
176
  /* show selected group's widget */
 
177
  gtk_widget_show_all(group_widget);
 
178
 
 
179
  current_group_widget = group_widget;
 
180
 
 
181
  free(group_name);
 
182
  return TRUE;
 
183
}
 
184
 
 
185
 
 
186
static void
 
187
quit_confirm_dialog_response_cb(GtkDialog *dialog, gint arg, gpointer user_data)
 
188
{
 
189
  gboolean *quit = user_data;
 
190
 
 
191
  switch (arg)
 
192
  {
 
193
  case GTK_RESPONSE_YES:
 
194
  case GTK_RESPONSE_OK:
 
195
    *quit = TRUE;
 
196
    break;
 
197
  case GTK_RESPONSE_CANCEL:
 
198
  case GTK_RESPONSE_NO:
 
199
    *quit = FALSE;
 
200
    break;
 
201
  default:
 
202
    break;
 
203
  }
 
204
}
 
205
 
 
206
static void
 
207
quit_confirm(void)
 
208
{
 
209
  if (uim_pref_gtk_value_changed) {
 
210
    GtkWidget *dialog;
 
211
    gboolean quit = FALSE;
 
212
 
 
213
    dialog = gtk_message_dialog_new(NULL,
 
214
                                    GTK_DIALOG_MODAL,
 
215
                                    GTK_MESSAGE_QUESTION,
 
216
                                    GTK_BUTTONS_YES_NO,
 
217
                                    _("Some value(s) have been changed.\n"
 
218
                                      "Do you really quit this program?"));
 
219
    gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(pref_window));
 
220
    gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
 
221
    g_signal_connect(G_OBJECT(dialog), "response",
 
222
                     G_CALLBACK(quit_confirm_dialog_response_cb), &quit);
 
223
    gtk_dialog_run(GTK_DIALOG(dialog));
 
224
    gtk_widget_destroy(dialog);
 
225
 
 
226
    if (quit)
 
227
      gtk_main_quit();
 
228
  } else {
 
229
    gtk_main_quit();
 
230
  }
 
231
}
 
232
 
 
233
static gint
 
234
delete_event_cb(GtkWidget *widget, gpointer data)
 
235
{
 
236
  quit_confirm();
 
237
  return TRUE;
 
238
}
 
239
 
 
240
static GtkWidget *
 
241
create_pref_treeview(void)
 
242
{
 
243
  GtkTreeStore *tree_store;
 
244
  GtkCellRenderer *renderer;
 
245
  GtkTreeViewColumn *column;
 
246
  GtkTreeIter iter;
 
247
  char **primary_groups, **grp;
 
248
  GtkTreeSelection *selection;
 
249
  GtkTreePath *first_path;
 
250
  tree_store = gtk_tree_store_new (NUM_COLUMNS,
 
251
                                   G_TYPE_STRING,
 
252
                                   GTK_TYPE_WIDGET);
 
253
 
 
254
  pref_tree_view = gtk_tree_view_new();
 
255
 
 
256
  renderer = gtk_cell_renderer_text_new();
 
257
  column = gtk_tree_view_column_new_with_attributes(_("Group"),
 
258
                                                    renderer,
 
259
                                                    "text", GROUP_COLUMN,
 
260
                                                    NULL);
 
261
  gtk_tree_view_column_set_sort_column_id(column, 0);
 
262
  gtk_tree_view_append_column(GTK_TREE_VIEW(pref_tree_view), column);
 
263
 
 
264
  primary_groups = uim_custom_primary_groups();
 
265
  for (grp = primary_groups; *grp; grp++) {
 
266
    struct uim_custom_group *group = uim_custom_group_get(*grp);
 
267
    gtk_tree_store_append (tree_store, &iter, NULL/* parent iter */);
 
268
    gtk_tree_store_set (tree_store, &iter,
 
269
                        GROUP_COLUMN, group->label,
 
270
                        GROUP_WIDGET, create_group_widget(*grp),
 
271
                        -1);
 
272
    uim_custom_group_free(group);
 
273
  }
 
274
  uim_custom_symbol_list_free( primary_groups );
 
275
 
 
276
  gtk_tree_view_set_model (GTK_TREE_VIEW(pref_tree_view),
 
277
                           GTK_TREE_MODEL(tree_store));
 
278
  g_object_unref (tree_store);
 
279
  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(pref_tree_view), TRUE);
 
280
  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pref_tree_view));
 
281
  gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
 
282
  g_signal_connect (G_OBJECT(selection), "changed",
 
283
                    G_CALLBACK(pref_tree_selection_changed), NULL);
 
284
 
 
285
  first_path = gtk_tree_path_new_from_indices (0, -1);
 
286
 
 
287
  gtk_tree_view_set_cursor(GTK_TREE_VIEW(pref_tree_view),
 
288
                           first_path, NULL, FALSE);
 
289
 
 
290
  return pref_tree_view;
 
291
}
 
292
 
 
293
static void
 
294
ok_button_clicked(GtkButton *button, gpointer user_data)
 
295
{
 
296
  /*const char *group_name = user_data;*/
 
297
 
 
298
  if (uim_pref_gtk_value_changed) {
 
299
    uim_custom_save();
 
300
    uim_custom_broadcast_reload_request();
 
301
    uim_pref_gtk_unmark_value_changed();
 
302
  }
 
303
 
 
304
  gtk_main_quit();
 
305
}
 
306
 
 
307
static void
 
308
apply_button_clicked(GtkButton *button, gpointer user_data)
 
309
{
 
310
  /*const char *group_name = user_data;*/
 
311
 
 
312
  if (uim_pref_gtk_value_changed) {
 
313
    uim_custom_save();
 
314
    uim_custom_broadcast_reload_request();
 
315
    uim_pref_gtk_unmark_value_changed();
 
316
  }
 
317
}
 
318
 
 
319
static void
 
320
set_to_default_cb(GtkWidget *widget, gpointer data)
 
321
{
 
322
  uim_pref_gtk_set_default_value(widget);
 
323
 
 
324
  if (GTK_IS_CONTAINER(widget))
 
325
    gtk_container_foreach(GTK_CONTAINER(widget),
 
326
                          (GtkCallback) (set_to_default_cb), NULL);
 
327
  uim_pref_gtk_mark_value_changed();
 
328
}
 
329
 
 
330
static void
 
331
defaults_button_clicked(GtkButton *button, gpointer user_data)
 
332
{
 
333
  gtk_container_foreach(GTK_CONTAINER(current_group_widget),
 
334
                        (GtkCallback) (set_to_default_cb), NULL);
 
335
}
 
336
 
 
337
static GtkWidget *
 
338
create_setting_button_box(const char *group_name)
 
339
{
 
340
  GtkWidget *setting_button_box;
 
341
  GtkWidget *button;
 
342
  GtkTooltips *tooltip;
 
343
 
 
344
  setting_button_box = gtk_hbutton_box_new();
 
345
  gtk_button_box_set_layout(GTK_BUTTON_BOX(setting_button_box), GTK_BUTTONBOX_END);
 
346
  gtk_box_set_spacing(GTK_BOX(setting_button_box), 8);
 
347
 
 
348
  /* Defaults button */
 
349
  button = gtk_button_new_with_mnemonic(_("_Defaults"));
 
350
  g_signal_connect(G_OBJECT(button), "clicked",
 
351
                   G_CALLBACK(defaults_button_clicked), (gpointer) group_name);
 
352
  gtk_box_pack_start(GTK_BOX(setting_button_box), button, TRUE, TRUE, 8);
 
353
  tooltip = gtk_tooltips_new();
 
354
  gtk_tooltips_set_tip(tooltip, button, _("Revert all changes to default"), NULL);
 
355
 
 
356
 
 
357
  /* Apply button */
 
358
  pref_apply_button = gtk_button_new_from_stock(GTK_STOCK_APPLY);
 
359
  g_signal_connect(G_OBJECT(pref_apply_button), "clicked",
 
360
                   G_CALLBACK(apply_button_clicked), (gpointer) group_name);
 
361
  gtk_widget_set_sensitive(pref_apply_button, FALSE);
 
362
  gtk_box_pack_start(GTK_BOX(setting_button_box), pref_apply_button, TRUE, TRUE, 8);
 
363
  tooltip = gtk_tooltips_new();
 
364
  gtk_tooltips_set_tip(tooltip, pref_apply_button, _("Apply all changes"), NULL);
 
365
 
 
366
  /* Cancel button */
 
367
  button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
 
368
  g_signal_connect(G_OBJECT(button), "clicked",
 
369
                   G_CALLBACK(quit_confirm), NULL);
 
370
  gtk_box_pack_start(GTK_BOX(setting_button_box), button, TRUE, TRUE, 8);
 
371
  tooltip = gtk_tooltips_new();
 
372
  gtk_tooltips_set_tip(tooltip, button, _("Quit this application without applying changes"), NULL);
 
373
 
 
374
  /* OK button */
 
375
  pref_ok_button = gtk_button_new_from_stock(GTK_STOCK_OK);
 
376
  g_signal_connect(G_OBJECT(pref_ok_button), "clicked",
 
377
                   G_CALLBACK(ok_button_clicked), (gpointer) group_name);
 
378
  gtk_box_pack_start(GTK_BOX(setting_button_box), pref_ok_button, TRUE, TRUE, 8);
 
379
#if USE_CHANGES_SENSITIVE_OK_BUTTON
 
380
  gtk_widget_set_sensitive(pref_ok_button, FALSE);
 
381
#endif
 
382
  tooltip = gtk_tooltips_new();
 
383
  gtk_tooltips_set_tip(tooltip, pref_ok_button, _("Quit this application with applying changes"), NULL);
 
384
 
 
385
  return setting_button_box;
 
386
}
 
387
 
 
388
static GtkWidget *
 
389
create_group_widget(const char *group_name)
 
390
{
 
391
  GtkWidget *vbox;
 
392
  GtkWidget *group_label;
 
393
  struct uim_custom_group *group;
 
394
  char *label_text;
 
395
  vbox = gtk_vbox_new(FALSE, 8);
 
396
 
 
397
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
 
398
 
 
399
  group = uim_custom_group_get(group_name);
 
400
 
 
401
  if (group == NULL)
 
402
    return NULL;
 
403
 
 
404
  group_label = gtk_label_new("");
 
405
  label_text  = g_markup_printf_escaped("<span size=\"xx-large\">%s</span>",
 
406
                                        group->label);
 
407
  gtk_label_set_markup(GTK_LABEL(group_label), label_text);
 
408
  g_free(label_text);
 
409
 
 
410
  gtk_box_pack_start (GTK_BOX(vbox), group_label, FALSE, TRUE, 8);
 
411
 
 
412
  create_sub_group_widgets(vbox, group_name);
 
413
 
 
414
  uim_custom_group_free(group);
 
415
 
 
416
  return vbox;
 
417
}
 
418
 
 
419
static void create_sub_group_widgets(GtkWidget *parent_widget, const char *parent_group)
 
420
{
 
421
    char **sgrp_syms = uim_custom_group_subgroups(parent_group);
 
422
    char **sgrp_sym;
 
423
 
 
424
    for (sgrp_sym = sgrp_syms; *sgrp_sym; sgrp_sym++)
 
425
    {
 
426
        struct uim_custom_group *sgrp =  uim_custom_group_get(*sgrp_sym);
 
427
        char **custom_syms, **custom_sym;
 
428
        GString *sgrp_str;
 
429
        GtkWidget *frame;
 
430
        GtkWidget *vbox;
 
431
 
 
432
        if (!sgrp)
 
433
          continue;
 
434
 
 
435
        /* XXX quick hack to use AND expression of groups */
 
436
        sgrp_str = g_string_new("");
 
437
        g_string_printf(sgrp_str, "%s '%s", parent_group, *sgrp_sym);
 
438
        custom_syms = uim_custom_collect_by_group(sgrp_str->str);
 
439
        g_string_free(sgrp_str, TRUE);
 
440
 
 
441
        if (!custom_syms)
 
442
          continue;
 
443
        if (!*custom_syms) {
 
444
          uim_custom_symbol_list_free(custom_syms);
 
445
          continue;
 
446
        }
 
447
 
 
448
        vbox = gtk_vbox_new(FALSE, 8);
 
449
        if (strcmp(*sgrp_sym, "main")) {
 
450
          frame = gtk_frame_new(sgrp->label);
 
451
          gtk_frame_set_label_align(GTK_FRAME(frame), 0.02, 0.5);
 
452
          gtk_box_pack_start(GTK_BOX(parent_widget), frame, FALSE, FALSE, 0);
 
453
 
 
454
          gtk_container_add(GTK_CONTAINER(frame), vbox);
 
455
        } else {
 
456
 
 
457
          /*
 
458
           * Removing frame for 'main' subgroup. If you feel it
 
459
           * strange, Replace it as you favor.  -- YamaKen 2005-02-06
 
460
           */
 
461
          gtk_box_pack_start(GTK_BOX(parent_widget), vbox, FALSE, FALSE, 0);
 
462
        }
 
463
 
 
464
        gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);
 
465
 
 
466
        for (custom_sym = custom_syms; *custom_sym; custom_sym++) {
 
467
          uim_pref_gtk_add_custom(vbox, *custom_sym);
 
468
        }
 
469
        uim_custom_symbol_list_free(custom_syms);
 
470
 
 
471
        uim_custom_group_free(sgrp);
 
472
    }
 
473
 
 
474
    uim_custom_symbol_list_free(sgrp_syms);
 
475
}
 
476
 
 
477
static GtkWidget *
 
478
create_pref_window(void)
 
479
{
 
480
  GtkWidget *window;
 
481
  GtkWidget *scrolled_win; /* treeview container */
 
482
  GtkWidget *vbox;
 
483
  GdkPixbuf *icon;
 
484
 
 
485
  pref_window = window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
486
 
 
487
  icon = gdk_pixbuf_new_from_file(UIM_PIXMAPSDIR"/uim-icon.png", NULL);
 
488
  gtk_window_set_icon(GTK_WINDOW(pref_window), icon);
 
489
 
 
490
  g_signal_connect(G_OBJECT (window), "delete_event",
 
491
                   G_CALLBACK (delete_event_cb), NULL);
 
492
 
 
493
 
 
494
  pref_hbox = gtk_hbox_new(FALSE, 8);
 
495
 
 
496
  scrolled_win = gtk_scrolled_window_new(NULL, NULL);
 
497
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win),
 
498
                                      GTK_SHADOW_ETCHED_IN);
 
499
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
 
500
                                 GTK_POLICY_NEVER,
 
501
                                 GTK_POLICY_AUTOMATIC);
 
502
  gtk_box_pack_start(GTK_BOX(pref_hbox), scrolled_win, FALSE, TRUE, 0);
 
503
 
 
504
  gtk_container_add(GTK_CONTAINER(scrolled_win), create_pref_treeview());
 
505
 
 
506
  vbox = gtk_vbox_new(FALSE, 8);
 
507
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
 
508
  gtk_box_pack_start(GTK_BOX(vbox), pref_hbox, TRUE, TRUE, 0);
 
509
  gtk_box_pack_start(GTK_BOX(vbox), create_setting_button_box("dummy-group-name"), FALSE, TRUE, 0);
 
510
  gtk_container_add(GTK_CONTAINER(window), vbox);
 
511
 
 
512
  {
 
513
    GdkScreen *scr;
 
514
    gint w, h;
 
515
 
 
516
    scr = gtk_window_get_screen(GTK_WINDOW(window));
 
517
    w = CLAMP(gdk_screen_get_width(scr)  * 0.95, 0, DEFAULT_WINDOW_WIDTH_MAX);
 
518
    h = CLAMP(gdk_screen_get_height(scr) * 0.95, 0, DEFAULT_WINDOW_HEIGHT_MAX);
 
519
    gtk_window_set_default_size(GTK_WINDOW(window), w, h);
 
520
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
 
521
  }
 
522
 
 
523
  return window;
 
524
}
 
525
 
 
526
static gboolean
 
527
check_dot_uim_file(void)
 
528
{
 
529
  GString *dot_uim = g_string_new(g_get_home_dir());
 
530
  GtkWidget *dialog;
 
531
  const gchar *message =
 
532
    N_("The user customize file \"~/.uim\" is found.\n"
 
533
       "This file will override all conflicted settings set by\n"
 
534
       "this tool (stored in ~/.uim.d/customs/*.scm).\n"
 
535
       "Please check the file if you find your settings aren't applied.");
 
536
 
 
537
  g_string_append(dot_uim, "/.uim");
 
538
 
 
539
  if (!g_file_test(dot_uim->str, G_FILE_TEST_EXISTS)) {
 
540
    g_string_free(dot_uim, TRUE);
 
541
    return FALSE;
 
542
  }
 
543
  g_string_free(dot_uim, TRUE);
 
544
 
 
545
  dialog = gtk_message_dialog_new(NULL,
 
546
                                  GTK_DIALOG_MODAL,
 
547
                                  GTK_MESSAGE_WARNING,
 
548
                                  GTK_BUTTONS_OK,
 
549
                                  _(message));
 
550
  if (pref_window) {
 
551
    gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(pref_window));
 
552
    gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
 
553
  }
 
554
 
 
555
  /*
 
556
   *  2005-02-07 Takuro Ashie <ashie@homa.ne.jp>
 
557
   *    FIXME! We shoud add a check box like
 
558
   *    "Show this message every time on start up.".
 
559
   */
 
560
 
 
561
  gtk_dialog_run(GTK_DIALOG(dialog));
 
562
  gtk_widget_destroy(GTK_WIDGET(dialog));
 
563
 
 
564
  return FALSE;
 
565
}
 
566
 
 
567
int
 
568
main (int argc, char *argv[])
 
569
{
 
570
  setlocale(LC_ALL, "");
 
571
  bindtextdomain(PACKAGE, LOCALEDIR);
 
572
  textdomain(PACKAGE);
 
573
  bind_textdomain_codeset(PACKAGE, "UTF-8");
 
574
 
 
575
  gtk_set_locale();
 
576
 
 
577
  gtk_init(&argc, &argv);
 
578
 
 
579
  if (uim_init() < 0) {
 
580
    fprintf(stderr, "uim_init() failed.\n");
 
581
    return -1;
 
582
  }
 
583
 
 
584
  if (uim_custom_enable()) {
 
585
    GtkWidget *pref;
 
586
 
 
587
    im_uim_init_modifier_keys();
 
588
 
 
589
    gtk_idle_add((GtkFunction) check_dot_uim_file, NULL);
 
590
 
 
591
    pref = create_pref_window();
 
592
 
 
593
    gtk_widget_show_all(pref);
 
594
 
 
595
    gtk_main();
 
596
  } else {
 
597
    fprintf(stderr, "uim_custom_enable() failed.\n");
 
598
    uim_quit();
 
599
    return -1;
 
600
  }
 
601
 
 
602
  uim_quit();
 
603
  return 0;
 
604
}