ism/extras/gtk_panel/isf_setup_win.cpp

   1 /*
   2  * ISF(Input Service Framework)
   3  *
   4  * ISF is based on SCIM 1.4.7 and extended for supporting more mobile fitable.
   5  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   6  *
   7  * Contact: Shuo Liu <shuo0805.liu@samsung.com>, Hengliang Luo <hl.luo@samsung.com>
   8  *
   9  * This library is free software; you can redistribute it and/or modify it under
  10  * the terms of the GNU Lesser General Public License as published by the
  11  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  15  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  17  * License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  21  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  *
  23  */
  24
  25 #define Uses_SCIM_CONFIG_PATH
  26 #define Uses_SCIM_IMENGINE_MODULE
  27 #define Uses_SCIM_PANEL_AGENT
  28
  29
  30 #include <cstring>
  31 #include <cstdio>
  32 #include <gdk/gdk.h>
  33 #include "scim_private.h"
  34 #include "scim.h"
  35 #include "isf_setup_win.h"
  36 #include "isf_setup_utility.h"
  37 #include "scim_setup_module.h"
  38 #include "isf_ise_setup_win.h"
  39 #include "isf_help_win.h"
  40 #include "isf_lang_win.h"
  41
  42 #define LIST_ICON_SIZE             20
  43
  44 enum {
  45     FACTORY_LIST_ENABLE = 0,
  46     FACTORY_LIST_ICON,
  47     FACTORY_LIST_NAME,
  48     FACTORY_LIST_MODULE_NAME,
  49     FACTORY_LIST_UUID,
  50     FACTORY_LIST_TYPE,
  51     FACTORY_LIST_OPTION_PIX,
  52     FACTORY_LIST_HELP_PIX,
  53     FACTORY_LIST_NUM_COLUMNS
  54 };
  55
  56 static SetupUI                *_setup_ui               = 0;
  57 static ISFHelpWin             *_ise_help_win           = 0;
  58 static ISFLangWin             *_isf_lang_win           = 0;
  59 static GtkListStore           *_app_list_store         = 0;
  60 static GtkListStore           *_factory_list_store     = 0;
  61 static GtkTreePath            *_app_combo_default_path = 0;
  62 static GtkWidget              *_combo_app              = 0;
  63 static GtkWidget              *_main_window            = 0;
  64 static int                     _display_selected_items = 0;
  65 static ConfigPointer           _config;
  66
  67 extern std::vector<String>    _isf_app_list;
  68 extern MapStringVectorSizeT   _groups;
  69 extern std::vector < String > _uuids;
  70 extern std::vector < String > _names;
  71 extern std::vector < String > _module_names;
  72 extern std::vector < String > _langs;
  73 extern std::vector < String > _icons;
  74 extern std::vector <TOOLBAR_MODE_T> _modes;
  75 extern MapStringString        _keyboard_ise_help_map;
  76 extern MapStringVectorString  _disabled_ise_map;
  77 extern std::vector <String>   _disabled_langs;
  78 extern MapStringVectorString  _disabled_ise_map_bak;
  79 extern std::vector <String>   _disabled_langs_bak;
  80 extern gboolean               _lang_selected_changed;
  81 extern gboolean               _ise_list_changed;
  82 extern gboolean               _setup_enable_changed;
  83 extern int                    _screen_width;
  84 extern float                  _width_rate;
  85 extern float                  _height_rate;
  86
  87
  88 ISFSetupWin::ISFSetupWin (const ConfigPointer & config)
  89 {
  90     _config = config;
  91 #if HAVE_GCONF
  92     if (!_main_window) {
  93         _main_window = gtk_main_window_new (GTK_WIN_STYLE_DEFAULT);
  94         gtk_main_window_set_title_style (GTK_MAIN_WINDOW (_main_window), GTK_WIN_TITLE_STYLE_TEXT_ICON);
  95
  96         GtkWidget *form = gtk_form_new (TRUE);
  97         gtk_form_set_title (GTK_FORM (form), "ISF Setup");
  98
  99         GtkWidget *isf_setup = create_isf_setup_widget ();
 100
 101         gtk_container_add (GTK_CONTAINER (form), isf_setup);
 102
 103 #ifdef USING_ISF_SWITCH_BUTTON
 104         GtkWidget *softkey = GTK_WIDGET (gtk_form_get_softkey_bar (GTK_FORM (form)));
 105         gtk_softkey_bar_use_ise_switch (GTK_SOFTKEY_BAR (softkey), false);
 106
 107         gtk_softkey_bar_set_softkey (GTK_SOFTKEY_BAR (softkey), SOFTKEY1,
 108                                      "Save", NULL,
 109                                      (SoftkeyActionType) SOFTKEY_CALLBACK,
 110                                      (gpointer) (isf_setup_save_callback),
 111                                      (gpointer) NULL);
 112
 113         gtk_softkey_bar_set_softkey (GTK_SOFTKEY_BAR (softkey), SOFTKEY4,
 114                                      "Exit", NULL,
 115                                      (SoftkeyActionType) SOFTKEY_CALLBACK,
 116                                      (gpointer) (isf_setup_back_callback),
 117                                      (gpointer) NULL);
 118 #else
 119         gtk_form_add_softkey (GTK_FORM (form), "Save", NULL, SOFTKEY_CALLBACK, (void *)isf_setup_save_callback, NULL);
 120         gtk_form_add_softkey (GTK_FORM (form), "Exit", NULL, SOFTKEY_CALLBACK, (void *)isf_setup_back_callback, NULL);
 121 #endif
 122
 123         gtk_main_window_add_form (GTK_MAIN_WINDOW (_main_window), GTK_FORM (form));
 124         gtk_main_window_set_current_form (GTK_MAIN_WINDOW (_main_window), GTK_FORM (form));
 125
 126         gtk_widget_show_all (form);
 127     }
 128 #endif
 129 }
 130
 131 ISFSetupWin::~ISFSetupWin ()
 132 {
 133     if (_main_window) {
 134         gtk_widget_destroy (_main_window);
 135         _main_window = 0;
 136     }
 137     if (_setup_ui) {
 138         delete _setup_ui;
 139         _setup_ui = 0;
 140     }
 141     if (_ise_help_win) {
 142         delete _ise_help_win;
 143         _ise_help_win = 0;
 144     }
 145     if (_isf_lang_win) {
 146         delete _isf_lang_win;
 147         _isf_lang_win = 0;
 148     }
 149 }
 150
 151 void ISFSetupWin::show_window (void)
 152 {
 153     GtkTreeIter it;
 154     gtk_tree_model_get_iter (GTK_TREE_MODEL (_app_list_store), &it,
 155                              _app_combo_default_path);
 156     gtk_combo_box_set_active_iter ((GtkComboBox *) _combo_app, &it);
 157
 158     update_factory_list_store ();
 159
 160     gtk_widget_show_all (_main_window);
 161     gtk_window_present (GTK_WINDOW (_main_window));
 162     gtk_main ();
 163 }
 164
 165
 166 void ISFSetupWin::app_selection_changed_callback (GtkComboBox * combo, gpointer data)
 167 {
 168     ISFSetupWin *obj = (ISFSetupWin *)data;
 169     obj->update_factory_list_store ();
 170 }
 171
 172
 173 void ISFSetupWin::on_language_button_clicked_callback (GtkButton * button,
 174                                                        gpointer user_data)
 175 {
 176     ISFSetupWin *obj = (ISFSetupWin *)user_data;
 177
 178     if (!_isf_lang_win)
 179         _isf_lang_win = new ISFLangWin ();
 180     if (_isf_lang_win)
 181         _isf_lang_win->show_window ();
 182
 183     if (_lang_selected_changed) {
 184         _ise_list_changed = true;
 185         obj->update_factory_list_store ();
 186     }
 187 }
 188
 189 GtkWidget *ISFSetupWin::create_isf_setup_widget (void)
 190 {
 191     GtkWidget *language_button = NULL, *hbox = NULL, *vbox = NULL, *scroll = NULL;
 192
 193     GtkTreeIter      iter, it;
 194     GtkCellRenderer *cell = NULL;
 195
 196     vbox = gtk_vbox_new (FALSE, 0);
 197     gtk_widget_show (vbox);
 198
 199     hbox = gtk_hbox_new (FALSE, 0);
 200     gtk_widget_show (hbox);
 201     gtk_box_pack_start (GTK_BOX (vbox), hbox, false, false, 0);
 202     gtk_widget_set_size_request (hbox, _screen_width, (int)(40*_height_rate));
 203     gtk_container_set_border_width (GTK_CONTAINER (hbox),(int)( 5*_height_rate));
 204
 205     // Create application list combox
 206     _combo_app = gtk_combo_box_new ();
 207     cell = gtk_cell_renderer_text_new ();
 208     _app_list_store = gtk_list_store_new (1, G_TYPE_STRING);
 209
 210     for (unsigned int i = 0; i < _isf_app_list.size (); i++) {
 211         gtk_list_store_prepend (_app_list_store, &iter);
 212         gtk_list_store_set (_app_list_store, &iter, 0, _isf_app_list[_isf_app_list.size () - i - 1].c_str (), -1);
 213     }
 214
 215     _app_combo_default_path = gtk_tree_model_get_path (GTK_TREE_MODEL (_app_list_store), &iter);
 216
 217     gtk_cell_layout_pack_start ((GtkCellLayout *) _combo_app, cell, TRUE);
 218     gtk_cell_layout_set_attributes ((GtkCellLayout *) _combo_app, cell, "text", 0, NULL);
 219     gtk_combo_box_set_model ((GtkComboBox *) _combo_app, (GtkTreeModel *) _app_list_store);
 220     gtk_tree_model_get_iter (GTK_TREE_MODEL (_app_list_store), &it, _app_combo_default_path);
 221     gtk_combo_box_set_active_iter ((GtkComboBox *) _combo_app, &it);
 222 //    gtk_widget_show (_combo_app);  //hide the app list combox temp
 223     g_signal_connect ((gpointer) _combo_app, "changed",
 224                       G_CALLBACK (app_selection_changed_callback), (gpointer)this);
 225
 226     // Create language button
 227     language_button = gtk_button_new_with_label ("Language");
 228     GtkStyle *style1 = gtk_rc_get_style (language_button);
 229     GtkWidget *newlabel = gtk_label_new ("Language");
 230     if (newlabel) {
 231         GtkWidget * old = gtk_bin_get_child (GTK_BIN (language_button));
 232         if (old)
 233             gtk_container_remove (GTK_CONTAINER (language_button), old);
 234         gtk_container_add (GTK_CONTAINER (language_button), newlabel);
 235     }
 236     if(style1)
 237     {
 238         gtk_widget_modify_font (language_button, style1->font_desc);
 239     }
 240     gtk_widget_show (language_button);
 241     gtk_box_pack_start (GTK_BOX (hbox), language_button, true, true, 0);
 242     g_signal_connect ((gpointer) language_button, "clicked",
 243                       G_CALLBACK (on_language_button_clicked_callback), (gpointer)this);
 244
 245     // Create ISE list view
 246     scroll = gtk_scrolled_window_new (NULL, NULL);
 247     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
 248                                     GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 249     gtk_container_add (GTK_CONTAINER (vbox), scroll);
 250     gtk_widget_show (scroll);
 251
 252     GtkWidget *view = create_factory_list_view ();
 253     create_and_fill_factory_list_store ();
 254     gtk_tree_view_set_model (GTK_TREE_VIEW  (view), GTK_TREE_MODEL (_factory_list_store));
 255     gtk_container_add (GTK_CONTAINER (scroll), view);
 256     gtk_widget_show (view);
 257
 258     return vbox;
 259 }
 260
 261 // Show all ISEs in the view
 262 void ISFSetupWin::create_and_fill_factory_list_store (void)
 263 {
 264     _factory_list_store = gtk_list_store_new (FACTORY_LIST_NUM_COLUMNS, G_TYPE_BOOLEAN,
 265                                               GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
 266                                               G_TYPE_STRING, G_TYPE_INT, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF);
 267     update_factory_list_store ();
 268 }
 269
 270 void ISFSetupWin::update_factory_list_store (void)
 271 {
 272     GtkTreeIter  iter;
 273
 274     GdkPixbuf   *icon = NULL, *icon2 = NULL;
 275     GtkWidget   *pix = NULL, *pix2 = NULL;
 276
 277     _display_selected_items = 0;
 278     pix   = gtk_image_new_from_file (ISE_SETUP_ICON_FILE);
 279     icon  = gtk_image_get_pixbuf (GTK_IMAGE (pix));
 280     pix2  = gtk_image_new_from_file (ISE_HELP_ICON_FILE);
 281     icon2 = gtk_image_get_pixbuf (GTK_IMAGE (pix2));
 282
 283     String _app_name = gtk_combo_box_get_active_text ((GtkComboBox *) _combo_app);
 284
 285     gtk_list_store_clear (_factory_list_store);
 286     std::vector<String>  f_show;
 287     for (MapStringVectorSizeT::iterator it = _groups.begin (); it != _groups.end (); ++it) {
 288         String lang_name;
 289         lang_name = scim_get_language_name (it->first);
 290         if (std::find (_disabled_langs.begin (), _disabled_langs.end (), lang_name) == _disabled_langs.end ()) {
 291             for (size_t i = 0; i < it->second.size (); i++) {
 292                 // protect from add the same ise more than once in case of multiple langs.-->f_show list
 293                 if (std::find (f_show.begin (), f_show.end (), _uuids[it->second[i]]) == f_show.end ()) {
 294                     gtk_list_store_append (_factory_list_store, &iter);
 295                     gtk_list_store_set (_factory_list_store, &iter,
 296                                         FACTORY_LIST_NAME,
 297                                         _names[it->second[i]].c_str (),
 298                                         FACTORY_LIST_MODULE_NAME,
 299                                         _module_names[it->second[i]].c_str (),
 300                                         FACTORY_LIST_UUID,
 301                                         _uuids[it->second[i]].c_str (),
 302                                         FACTORY_LIST_TYPE, (gint)_modes[it->second[i]],
 303                                         FACTORY_LIST_OPTION_PIX, icon,
 304                                         FACTORY_LIST_HELP_PIX,icon2,
 305                                         -1);
 306                     f_show.push_back (_uuids[it->second[i]]);
 307
 308
 309                     if (std::find (_disabled_ise_map[_app_name].begin (), _disabled_ise_map[_app_name].end (), _uuids[it->second[i]])
 310                         ==_disabled_ise_map[_app_name].end ()) {
 311                         gtk_list_store_set (_factory_list_store, &iter, FACTORY_LIST_ENABLE, true, -1);
 312                         _display_selected_items++;
 313                     } else {
 314                         gtk_list_store_set (_factory_list_store, &iter, FACTORY_LIST_ENABLE, false, -1);
 315                     }
 316                 }
 317             }
 318         }
 319     }
 320
 321     if (icon) {
 322         gdk_pixbuf_unref (icon);
 323         icon = 0;
 324     }
 325     if (icon2) {
 326         gdk_pixbuf_unref (icon2);
 327         icon2 = 0;
 328     }
 329 }
 330
 331 GtkWidget * ISFSetupWin::create_factory_list_view (void)
 332 {
 333     GtkCellRenderer*     renderer = NULL;
 334     GtkTreeViewColumn*   column   = NULL;
 335
 336     GtkWidget *tv = gtk_tree_view_new ();
 337     g_object_set (tv, "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_NONE, NULL);
 338     column = gtk_tree_view_column_new ();
 339
 340     //toggle renderer
 341     renderer = gtk_cell_renderer_toggle_new ();
 342     g_object_set (renderer, "activatable", TRUE, NULL);
 343     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), renderer, FALSE);
 344     gtk_cell_renderer_set_fixed_size (renderer, _screen_width/8, (gint)(40*_height_rate));
 345     g_object_set (renderer, "xalign", 0.5, NULL);
 346     g_object_set (renderer, "radio", 0, NULL);
 347     g_object_set (renderer, "indicator-size", (gint)(26*(_width_rate < _height_rate ? _width_rate : _height_rate)), NULL);
 348     gtk_tree_view_column_set_attributes (column, renderer, "active", FACTORY_LIST_ENABLE, NULL);
 349     g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (on_factory_enable_box_clicked), (gpointer) NULL);
 350
 351     // text renderer
 352     renderer =  gtk_cell_renderer_text_new ();
 353     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), renderer, FALSE);
 354     gtk_tree_view_column_set_attributes (column, renderer, "text", FACTORY_LIST_NAME, NULL);
 355     gtk_cell_renderer_set_fixed_size (renderer, (gint)(_screen_width*5/8), (gint)(40*_height_rate));
 356     g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 357     g_object_set (renderer, "xalign", 0.0, NULL);
 358 #if HAVE_GCONF
 359     gtk_cell_renderer_set_cell_flag (tv, renderer, GTK_CELL_RENDERER_MAINCELL);
 360 #endif
 361     gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 362
 363     // pixbuf render
 364     column = gtk_tree_view_column_new ();
 365     renderer = gtk_cell_renderer_pixbuf_new ();
 366 #if HAVE_GCONF
 367     renderer->cell_type = GTK_CELL_RENDERER_ICONCELL;
 368 #endif
 369     gtk_tree_view_column_pack_start (column, renderer, FALSE);
 370     gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", FACTORY_LIST_HELP_PIX, NULL);
 371     gtk_cell_renderer_set_fixed_size (renderer, _screen_width/11, _screen_width/10);
 372     g_object_set (renderer, "xalign", 0.5, NULL);
 373     g_object_set (renderer, "yalign", 0.5, NULL);
 374     gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 375
 376     // pixbuf render
 377     column = gtk_tree_view_column_new ();
 378     renderer = gtk_cell_renderer_pixbuf_new ();
 379 #if HAVE_GCONF
 380     renderer->cell_type = GTK_CELL_RENDERER_ICONCELL;
 381 #endif
 382     gtk_tree_view_column_pack_start (column, renderer, FALSE);
 383     gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", FACTORY_LIST_OPTION_PIX, NULL);
 384     gtk_cell_renderer_set_fixed_size (renderer, _screen_width/11, _screen_width/10);
 385     g_object_set (renderer, "yalign", 0.5, NULL);
 386     g_object_set (renderer, "xalign", 0.5, NULL);
 387     gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 388
 389 #if HAVE_GCONF
 390     gtk_tree_view_set_special_row_selection_indicator (GTK_TREE_VIEW (tv), TRUE);
 391 #endif
 392     gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tv), false);
 393     g_signal_connect (GTK_TREE_VIEW (tv), "button_press_event", G_CALLBACK (button_press_cb), this);
 394     gtk_widget_show_all (tv);
 395
 396     return tv;
 397 }
 398
 399 gboolean ISFSetupWin::button_press_cb (GtkWidget *widget, GdkEventButton *event, gpointer data)
 400 {
 401     ISFSetupWin  *obj   = (ISFSetupWin *)data;
 402     GtkTreePath  *path  = NULL;
 403     GtkTreeModel *model = GTK_TREE_MODEL (_factory_list_store);
 404     GtkTreeIter   iter;
 405     gchar        *module_name = NULL, *title = NULL;
 406     int           type;
 407     int           cell_x, cell_y;
 408
 409     GtkTreeViewColumn *column = NULL;
 410     if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
 411                                         (gint)event->x, (gint)event->y,
 412                                         &path, &column, &cell_x, &cell_y))
 413         return (gboolean)FALSE;
 414
 415     if (path != NULL) {
 416         gtk_tree_model_get_iter (model, &iter, path);
 417         gtk_tree_path_free (path);
 418         gtk_tree_model_get (model, &iter, FACTORY_LIST_MODULE_NAME,
 419                             &module_name, FACTORY_LIST_NAME, &title, FACTORY_LIST_TYPE, &type, -1);
 420
 421         GtkTreeView *tree_view = NULL;
 422         tree_view = GTK_TREE_VIEW (widget);
 423         if (event->window == gtk_tree_view_get_bin_window (tree_view)) {
 424             if (event->type == GDK_BUTTON_PRESS) {
 425                 if (column == gtk_tree_view_get_column (tree_view, 1)) {
 426                     obj->create_ise_help_main (type, module_name, title);
 427                     return (gboolean)TRUE;
 428                 } else if (column == gtk_tree_view_get_column (tree_view, 2)) {
 429                     obj->create_ise_option_main (module_name);
 430                     return (gboolean)TRUE;
 431                 }
 432             }
 433         }
 434     }
 435     return (gboolean)FALSE;
 436 }
 437
 438 void ISFSetupWin::create_ise_option_main (const char *str)
 439 {
 440     if (!_setup_ui)
 441         _setup_ui = new SetupUI (_config);
 442     if (!_setup_ui)
 443         return;
 444
 445     String setup_module_name;
 446     setup_module_name = utf8_wcstombs (utf8_mbstowcs (str)) + String ("-imengine-setup");
 447
 448     SetupModule *setup_module = new SetupModule (setup_module_name);
 449
 450     if (setup_module) {
 451         _setup_ui->add_module (setup_module);
 452         delete setup_module;
 453     }
 454 }
 455
 456
 457 void ISFSetupWin::create_ise_help_main (gint type, char *name, char *title)
 458 {
 459     if (!_ise_help_win)
 460         _ise_help_win = new ISFHelpWin ();
 461     if (!_ise_help_win)
 462         return;
 463
 464     TOOLBAR_MODE_T mode = TOOLBAR_MODE_T (type);
 465     // for mutually exclusive ISEs
 466     if (TOOLBAR_HELPER_MODE == mode) {
 467         String help_filename, help_line;
 468
 469         if (TOOLBAR_HELPER_MODE == mode) {
 470             help_filename = String (SCIM_MODULE_PATH) + String (SCIM_PATH_DELIM_STRING)
 471                             + String (SCIM_BINARY_VERSION) + String (SCIM_PATH_DELIM_STRING) + String ("Helper")
 472                             + String (SCIM_PATH_DELIM_STRING) + String (name)
 473                             + String (".help");
 474         }
 475
 476         std::ifstream helpfile (help_filename.c_str ());
 477         if (!helpfile) {
 478             std::cerr << "Can't open help file : " << help_filename << "!!!!!!!!!! \n";
 479
 480             help_line = String (_("Input Service Framework ")) +
 481                         String (_("\n(C) 2008 SAMSUNG")) +
 482                         String (_("\n\n Help file is needed!!"));
 483         } else {
 484             /* FIXME -- 256 char per line for now -- */
 485             char str[256];
 486             while (helpfile.getline (str, sizeof (str))) {
 487                 help_line = help_line + String (str) + String("\n");
 488             }
 489             helpfile.close ();
 490         }
 491         _ise_help_win->show_help (title, (char *)help_line.c_str ());
 492     } else {
 493         // FIXME
 494         _ise_help_win->show_help (title, (char *)_keyboard_ise_help_map[String(name)].c_str ());
 495     }
 496 }
 497
 498 // Check before back
 499 int ISFSetupWin::get_app_active_ise_number (String app_name)
 500 {
 501     if (app_name.length () <= 0)
 502         return 0;
 503
 504     int         nCount = 0;
 505     String      lang_name;
 506
 507     for (MapStringVectorSizeT::iterator it = _groups.begin (); it != _groups.end (); ++it) {
 508         lang_name = scim_get_language_name (it->first);
 509         if (std::find (_disabled_langs.begin (), _disabled_langs.end (), lang_name) == _disabled_langs.end ()) {
 510             for (size_t i = 0; i < it->second.size (); i++) {
 511                 if (std::find (_disabled_ise_map_bak[app_name].begin (), _disabled_ise_map_bak[app_name].end (), _uuids[it->second[i]])
 512                         ==_disabled_ise_map_bak[app_name].end ()) {
 513                     nCount++;
 514                 }
 515             }
 516         }
 517     }
 518     return nCount;
 519 }
 520
 521 void ISFSetupWin::isf_setup_save_callback (GtkWidget *softkey, gpointer user_data)
 522 {
 523     if (_display_selected_items == 0) {
 524         GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW (_main_window),
 525                                                     GTK_DIALOG_MODAL,
 526                                                     GTK_MESSAGE_INFO,
 527                                                     GTK_BUTTONS_OK,
 528                                                     _("At least select one ISE!\n"));
 529         gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
 530         gtk_dialog_run (GTK_DIALOG (dialog));
 531         gtk_widget_destroy (dialog);
 532         return;
 533     }
 534
 535     for (size_t i = 0; i < _isf_app_list.size (); i++) {
 536         String app = _isf_app_list[i];
 537         _disabled_ise_map_bak[app].clear ();
 538         if (_disabled_ise_map[app].size ()) {
 539             for (size_t j = 0; j < _disabled_ise_map[app].size (); j++) {
 540                 _disabled_ise_map_bak[app].push_back (_disabled_ise_map[app][j]);
 541             }
 542         }
 543     }
 544
 545     if (_setup_enable_changed) {
 546         for (size_t i = 0; i < _isf_app_list.size (); i++) {
 547             String app = _isf_app_list[i];
 548             scim_global_config_write (String (SCIM_GLOBAL_CONFIG_DISABLED_IMENGINE_FACTORIES
 549                                               "/") + _isf_app_list[i], _disabled_ise_map[app]);
 550         }
 551         scim_global_config_flush ();
 552     }
 553     gtk_widget_hide (_main_window);
 554     gtk_main_quit ();
 555 }
 556
 557 void ISFSetupWin::isf_setup_back_callback (GtkWidget *softkey, gpointer user_data)
 558 {
 559     if (get_app_active_ise_number (_isf_app_list[0]) == 0) {
 560         GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW (_main_window),
 561                                                     GTK_DIALOG_MODAL,
 562                                                     GTK_MESSAGE_INFO,
 563                                                     GTK_BUTTONS_OK,
 564                                                    _("Please select ISE, then save.\n"));
 565         gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
 566         gtk_dialog_run (GTK_DIALOG (dialog));
 567         gtk_widget_destroy (dialog);
 568         return;
 569     }
 570     _setup_enable_changed = false;
 571     for (size_t i = 0; i < _isf_app_list.size (); i++) {
 572         String app = _isf_app_list[i];
 573         _disabled_ise_map[app].clear ();
 574         if (_disabled_ise_map_bak[app].size ()) {
 575             for (size_t j = 0; j < _disabled_ise_map_bak[app].size (); j++) {
 576                 _disabled_ise_map[app].push_back (_disabled_ise_map_bak[app][j]);
 577             }
 578         }
 579     }
 580
 581     gtk_widget_hide (_main_window);
 582     gtk_main_quit ();
 583 }
 584
 585 void ISFSetupWin::on_factory_enable_box_clicked (GtkCellRendererToggle *cell, gchar *arg1, gpointer data)
 586 {
 587     GtkTreePath *path = 0;
 588     GtkTreeIter  iter;
 589     gboolean     enable;
 590
 591     std::vector < String >::iterator it;
 592
 593     _setup_enable_changed = true;
 594
 595     path = gtk_tree_path_new_from_string (arg1);
 596     if (gtk_tree_model_get_iter (GTK_TREE_MODEL (_factory_list_store), &iter, path)) {
 597         gtk_tree_model_get (GTK_TREE_MODEL (_factory_list_store), &iter,
 598                             FACTORY_LIST_ENABLE, &enable, -1);
 599         gtk_list_store_set (GTK_LIST_STORE (_factory_list_store), &iter,
 600                             FACTORY_LIST_ENABLE, !enable, -1);
 601         if (enable)
 602             _display_selected_items--;
 603         else
 604             _display_selected_items++;
 605     }
 606     if (path) {
 607         gtk_tree_path_free (path);
 608         path = 0;
 609     }
 610
 611     gchar  *cuuid = 0;
 612     String  uuid;
 613     gtk_tree_model_get (GTK_TREE_MODEL (_factory_list_store),
 614                         &iter, FACTORY_LIST_UUID,
 615                         &cuuid, -1);
 616     uuid = (String)cuuid;
 617     if (cuuid) {
 618         g_free (cuuid);
 619         cuuid = 0;
 620     }
 621     String _app_name = gtk_combo_box_get_active_text ((GtkComboBox *) _combo_app);
 622     it = std::find (_disabled_ise_map[_app_name].begin (), _disabled_ise_map[_app_name].end (), uuid);
 623
 624     if (it != _disabled_ise_map[_app_name].end ())
 625         _disabled_ise_map[_app_name].erase (it);
 626     else
 627         _disabled_ise_map[_app_name].push_back (uuid);
 628 }
 629
 630 /*
 631 vi:ts=4:nowrap:ai:expandtab
 632 */