git.maemo.org Git - mdictionary/blob - src/gui/src/ws_gui_layout.c

   1 /*******************************************************************************
   2 This file is part of WhiteStork.
   3
   4 WhiteStork is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 WhiteStork is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with WhiteStork; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17
  18 Copyright 2006 ComArch S.A.
  19 *******************************************************************************/
  20 #include <ws_gui_layout.h>
  21 #include <ws_gui.h>
  22 #include <ws_gui_callbacks.h>
  23 #include <ws_dbus.h>
  24 #include <libintl.h>
  25
  26
  27 /** this function creates main window and it components; moreover there are
  28  * signal connections;
  29  *
  30  * @param user_data - data set when the signal handler was connected
  31  */
  32 void ws_gui_create_window(gpointer user_data)
  33 {
  34         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
  35
  36         ws_gui_app->welcome_note = g_strconcat("<br><br><center><font size=+3>",
  37                                    _("ws_ni_welcome"), "<br><IMG SRC=file:/usr/share/pixmaps/whitestork.png>",
  38                                    NULL);
  39
  40 //      ws_gui_app->ws_gui_w_list->ws_gui_list_item_data_string =
  41 //                                                   (ws_gui_app->welcome_note);
  42
  43         GArray *array_tmp = g_array_new (TRUE, TRUE, sizeof(gchar*));
  44         ws_gui_app->raw_translation = g_string_new(" ");
  45         ws_gui_app->last_searched = NULL;
  46         ws_gui_app->last_searched_in_book = NULL;
  47         ws_gui_app->last_word = NULL;
  48
  49         ws_gui_app->ws_gui_banner_flag = FALSE;
  50         ws_gui_app->ws_gui_full_screen_flag = FALSE;
  51         ws_gui_app->caching_flag = FALSE;
  52         ws_gui_app->ws_gui_double_click = FALSE;
  53         ws_gui_app->ws_gui_sel_flag = FALSE;
  54         ws_gui_app->bookmark_mode = FALSE;
  55         ws_gui_app->bookmark_avail = TRUE;
  56         ws_gui_app->html_flag = TRUE;
  57         ws_gui_app->loading = FALSE;
  58         ws_gui_app->stop_clicked = FALSE;
  59
  60         ws_gui_app->zoom = ZOOM_DEFAULT;
  61
  62         ws_gui_app->timer = g_timer_new();
  63         g_timer_stop(ws_gui_app->timer);
  64
  65         ws_gui_app->ws_gui_history = g_array_new(TRUE, TRUE, sizeof(gchar*));
  66         ws_gui_app->ws_gui_history_list = g_array_new(TRUE, TRUE, sizeof(gchar*));
  67         ws_gui_app->ws_gui_history_iter = g_array_new(TRUE, TRUE, sizeof(gchar*));
  68         ws_gui_app->history_flag = FALSE;
  69         ws_gui_app->ws_gui_history_cur_pos = -1;
  70
  71         ws_gui_app->ws_gui_hildon_program =
  72         HILDON_PROGRAM(hildon_program_get_instance());
  73
  74         g_set_application_name("WhiteStork");
  75
  76         ws_gui_app->ws_gui_hildon_window = HILDON_WINDOW(hildon_window_new());
  77
  78         hildon_program_add_window(ws_gui_app->ws_gui_hildon_program,
  79                                   ws_gui_app->ws_gui_hildon_window);
  80
  81         ws_gui_create_main_menu(ws_gui_app);
  82         ws_gui_create_find_toolbar(ws_gui_app);
  83
  84         ws_gui_app->ws_gui_hpane = gtk_hpaned_new();
  85
  86         ws_gui_app->ws_gui_scrolledwindow_left =
  87                 gtk_scrolled_window_new (NULL, NULL);
  88
  89         gtk_scrolled_window_set_policy(
  90                 GTK_SCROLLED_WINDOW (ws_gui_app->ws_gui_scrolledwindow_left),
  91                 GTK_POLICY_AUTOMATIC,
  92                 GTK_POLICY_AUTOMATIC);
  93
  94         gtk_paned_set_position(GTK_PANED(ws_gui_app->ws_gui_hpane), 100);
  95
  96         gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW
  97                                        (ws_gui_app->ws_gui_scrolledwindow_left),
  98                                        GTK_CORNER_TOP_LEFT);
  99
 100         ws_gui_app->ws_gui_scrolledwindow_right =
 101                 gtk_scrolled_window_new (NULL, NULL);
 102
 103         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW
 104                                      (ws_gui_app->ws_gui_scrolledwindow_right),
 105                                      GTK_POLICY_NEVER,
 106                                      GTK_POLICY_AUTOMATIC);
 107
 108         ws_gui_app->ws_gui_w_list->ws_gui_store =
 109                 gtk_list_store_new (NUM_COLS, G_TYPE_STRING, G_TYPE_UINT);
 110
 111         ws_gui_app->ws_gui_w_list->ws_gui_view =
 112                 create_view_and_model(array_tmp, ws_gui_app);
 113
 114         g_array_free(array_tmp, TRUE);
 115
 116         gtk_widget_show_all(GTK_WIDGET(ws_gui_app->ws_gui_w_list->ws_gui_view));
 117
 118         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW
 119                                        (ws_gui_app->ws_gui_scrolledwindow_left),
 120                                         ws_gui_app->ws_gui_w_list->ws_gui_view);
 121
 122         ws_gui_app->ws_gui_html = gtk_html_new();
 123
 124         ws_gui_app->p = pango_font_description_from_string("Tahoma 12");
 125         gtk_widget_modify_font(GTK_WIDGET(
 126                                         ws_gui_app->ws_gui_html),ws_gui_app->p);
 127
 128         g_signal_connect(GTK_OBJECT (ws_gui_app->ws_gui_html),
 129                                  "url_requested",
 130                                  G_CALLBACK(ws_gui_url_requested),
 131                                  ws_gui_app);
 132
 133         gtk_html_load_from_string(GTK_HTML(ws_gui_app->ws_gui_html),
 134                         ws_gui_app->welcome_note,
 135                         -1);
 136
 137         g_free(ws_gui_app->welcome_note);
 138         ws_gui_app->welcome_note = NULL;
 139
 140         gtk_html_set_magnification(GTK_HTML(ws_gui_app->ws_gui_html),
 141                                    ws_gui_app->zoom);
 142
 143         gtk_html_set_editable(GTK_HTML(ws_gui_app->ws_gui_html), FALSE);
 144         gtk_html_allow_selection(GTK_HTML(ws_gui_app->ws_gui_html), TRUE);
 145
 146         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW
 147                                       (ws_gui_app->ws_gui_scrolledwindow_right),
 148                                        ws_gui_app->ws_gui_html);
 149
 150         /*adding vbox & label - used for notifications */
 151
 152         ws_gui_app->ws_gui_list_image = gtk_image_new_from_file("/usr/share/pixmaps/ws_warning_icon.png");
 153         ws_gui_app->ws_gui_list_eventbox = gtk_event_box_new ();
 154         ws_gui_app->ws_gui_list_vbox = gtk_vbox_new(FALSE, 0);
 155         ws_gui_app->ws_gui_list_hbox = gtk_hbox_new(FALSE, 5);
 156         ws_gui_app->ws_gui_list_label = gtk_label_new(_("ws_ti_list_full"));
 157
 158         ws_gui_app->p = pango_font_description_from_string("Tahoma 10");
 159         gtk_widget_modify_font(GTK_WIDGET(ws_gui_app->ws_gui_list_label), ws_gui_app->p);
 160
 161         /*HBox packing ....*/
 162         gtk_box_pack_start(GTK_BOX(ws_gui_app->ws_gui_list_hbox),
 163                            ws_gui_app->ws_gui_list_image,
 164                            FALSE,
 165                            FALSE,
 166                            0);
 167
 168         gtk_box_pack_start(GTK_BOX(ws_gui_app->ws_gui_list_hbox),
 169                            ws_gui_app->ws_gui_list_label,
 170                            FALSE,
 171                            FALSE,
 172                            0);
 173
 174         // gtk_widget_set_size_request (ws_gui_app->ws_gui_list_label, 150, -1);
 175
 176         /*VBox packing ....*/
 177         gtk_box_pack_start(GTK_BOX(ws_gui_app->ws_gui_list_vbox),
 178                            ws_gui_app->ws_gui_scrolledwindow_left,
 179                            TRUE,
 180                            TRUE,
 181                            0);
 182
 183         gtk_box_pack_start(GTK_BOX(ws_gui_app->ws_gui_list_vbox),
 184                            ws_gui_app->ws_gui_list_eventbox,
 185                            FALSE,
 186                            FALSE,
 187                            0);
 188
 189         gtk_container_add (GTK_CONTAINER (ws_gui_app->ws_gui_list_eventbox),
 190                            ws_gui_app->ws_gui_list_hbox);
 191         /************************************************/
 192
 193
 194         gtk_paned_pack1(GTK_PANED(ws_gui_app->ws_gui_hpane),
 195                        ws_gui_app->ws_gui_list_vbox,
 196                        TRUE,
 197                        TRUE);
 198         gtk_paned_pack2(GTK_PANED(ws_gui_app->ws_gui_hpane),
 199                        ws_gui_app->ws_gui_scrolledwindow_right,
 200                        TRUE,
 201                        TRUE);
 202
 203         gtk_container_add(GTK_CONTAINER(ws_gui_app->ws_gui_hildon_window),
 204                         ws_gui_app->ws_gui_hpane);
 205
 206         gtk_widget_show_all(GTK_WIDGET(ws_gui_app->ws_gui_hildon_window));
 207
 208         gtk_widget_hide(GTK_WIDGET(ws_gui_app->ws_gui_list_hbox));
 209
 210         ws_gui_app->ws_gui_w_list->ws_gui_selection =
 211                 gtk_tree_view_get_selection (GTK_TREE_VIEW
 212                 (ws_gui_app->ws_gui_w_list->ws_gui_view));
 213
 214         gtk_tree_selection_set_mode(
 215                                    ws_gui_app->ws_gui_w_list->ws_gui_selection,
 216                                      GTK_SELECTION_BROWSE);
 217
 218         ws_gui_app->directories = g_slist_alloc();
 219         ws_gui_set_bookmarks_sensitivity(ws_gui_app);
 220
 221         ws_gui_app->ws_gui_banner_list_searching = hildon_banner_show_animation(
 222                                    GTK_WIDGET(ws_gui_app->ws_gui_hildon_window),
 223                                    NULL,
 224                                    _("ws_ab_searching"));
 225
 226         ws_gui_app->ws_gui_banner_translation_loading = hildon_banner_show_animation(
 227                                    GTK_WIDGET(ws_gui_app->ws_gui_hildon_window),
 228                                    NULL,
 229                                    _("ws_ab_loading"));
 230
 231         gtk_widget_set_sensitive(GTK_WIDGET
 232                         (ws_gui_app->ws_gui_menu->ws_gui_popup_bookmark),
 233                         FALSE);
 234
 235         gtk_widget_hide(GTK_WIDGET(ws_gui_app->ws_gui_banner_list_searching));
 236         gtk_widget_hide(GTK_WIDGET(ws_gui_app->ws_gui_banner_translation_loading));
 237 }
 238
 239 /** this function creates a find toolbar and connects signals to the tollbars
 240  * components
 241  *
 242  * @param user_data - set when the signal handler was connected
 243  */
 244 void ws_gui_create_find_toolbar(gpointer user_data)
 245 {
 246         WSGuiApp* ws_gui_app = (WSGuiApp*)user_data;
 247
 248         GtkToolItem *space;
 249         ws_gui_app->ws_gui_hildon_find_toolbar =
 250         HILDON_FIND_TOOLBAR(hildon_find_toolbar_new(_("ws_me_search_find")));
 251
 252         ws_gui_app->ws_gui_toobar_button_hide =
 253         gtk_toggle_tool_button_new_from_stock(GTK_STOCK_GOTO_FIRST);
 254         ws_gui_app->ws_gui_toobar_button_back =
 255         gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
 256         ws_gui_app->ws_gui_toobar_button_forward =
 257         gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
 258         ws_gui_app->ws_gui_toobar_button_stop =
 259         gtk_tool_button_new_from_stock(GTK_STOCK_STOP);
 260         space = gtk_separator_tool_item_new();
 261
 262         ws_gui_app->ws_gui_toobar_button_close =
 263                 gtk_toolbar_get_nth_item(GTK_TOOLBAR(
 264                                         ws_gui_app->ws_gui_hildon_find_toolbar),
 265                                         4);
 266
 267         ws_gui_app->ws_gui_toobar_button_start = gtk_toolbar_get_nth_item(GTK_TOOLBAR(
 268                                         ws_gui_app->ws_gui_hildon_find_toolbar),
 269                                         2);
 270
 271         gtk_tool_item_set_visible_horizontal(
 272                                 ws_gui_app->ws_gui_toobar_button_close,
 273                                 FALSE);
 274
 275         gtk_toolbar_insert(GTK_TOOLBAR(ws_gui_app->ws_gui_hildon_find_toolbar),
 276                                 ws_gui_app->ws_gui_toobar_button_hide,
 277                                 0);
 278         gtk_toolbar_insert(GTK_TOOLBAR(ws_gui_app->ws_gui_hildon_find_toolbar),
 279                                 ws_gui_app->ws_gui_toobar_button_back,
 280                                 -1);
 281         gtk_toolbar_insert(GTK_TOOLBAR(ws_gui_app->ws_gui_hildon_find_toolbar),
 282                                 ws_gui_app->ws_gui_toobar_button_forward,
 283                                 -1);
 284         gtk_toolbar_insert(GTK_TOOLBAR(ws_gui_app->ws_gui_hildon_find_toolbar),
 285                                 space,
 286                                 -1);
 287         gtk_toolbar_insert(GTK_TOOLBAR(ws_gui_app->ws_gui_hildon_find_toolbar),
 288                                 ws_gui_app->ws_gui_toobar_button_stop,
 289                                 -1);
 290
 291         g_signal_connect(G_OBJECT(ws_gui_app->ws_gui_hildon_find_toolbar),
 292                         "search",
 293                         G_CALLBACK(ws_gui_search),
 294                         ws_gui_app);
 295
 296         g_signal_connect(G_OBJECT(ws_gui_app->ws_gui_toobar_button_hide),
 297                         "toggled",
 298                         G_CALLBACK(ws_gui_words_list_hide),
 299                         ws_gui_app);
 300
 301         g_signal_connect(G_OBJECT(ws_gui_app->ws_gui_toobar_button_back),
 302                         "clicked",
 303                         G_CALLBACK(ws_gui_history_back),
 304                         ws_gui_app);
 305
 306         g_signal_connect(G_OBJECT(ws_gui_app->ws_gui_toobar_button_forward),
 307                         "clicked",
 308                         G_CALLBACK(ws_gui_history_next),
 309                         ws_gui_app);
 310         g_signal_connect(G_OBJECT(ws_gui_app->ws_gui_toobar_button_stop),
 311                         "clicked",
 312                         G_CALLBACK(ws_gui_search_stop),
 313                         ws_gui_app);
 314
 315         gtk_widget_set_sensitive(
 316                         GTK_WIDGET(ws_gui_app->ws_gui_toobar_button_back),
 317                         FALSE);
 318         gtk_widget_set_sensitive(
 319                         GTK_WIDGET(ws_gui_app->ws_gui_toobar_button_forward),
 320                         FALSE);
 321         gtk_widget_set_sensitive(
 322                         GTK_WIDGET(ws_gui_app->ws_gui_toobar_button_stop),
 323                         FALSE);
 324
 325         hildon_find_toolbar_highlight_entry((HildonFindToolbar*)(ws_gui_app->ws_gui_hildon_find_toolbar),
 326                                              FALSE);
 327         //gtk_toolbar_set_tooltips(GTK_TOOLBAR(ws_gui_app->ws_gui_hildon_find_toolbar), TRUE);
 328
 329         hildon_window_add_toolbar(ws_gui_app->ws_gui_hildon_window,
 330                         GTK_TOOLBAR(ws_gui_app->ws_gui_hildon_find_toolbar));
 331 }
 332
 333 /** this function creates application menu and its items and connect signals to
 334  * them
 335  *
 336  * @param user_data - set when the signal handler was connected
 337  */
 338 void ws_gui_create_main_menu (gpointer user_data)
 339 {
 340         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
 341
 342         ws_gui_app->ws_gui_menu->ws_gui_submenu_0 = gtk_menu_new();
 343         ws_gui_app->ws_gui_menu->ws_gui_submenu_1 = gtk_menu_new();
 344         ws_gui_app->ws_gui_menu->ws_gui_submenu_2 = gtk_menu_new();
 345         ws_gui_app->ws_gui_menu->ws_gui_submenu_3 = gtk_menu_new();
 346         ws_gui_app->ws_gui_menu->ws_gui_submenu_4 = gtk_menu_new();
 347         ws_gui_app->ws_gui_menu->ws_gui_main_menu = gtk_menu_new();
 348
 349         ws_gui_app->ws_gui_menu->ws_gui_menu_dictionaries =
 350                 gtk_menu_item_new_with_label(_("ws_me_dictionaries"));
 351         ws_gui_app->ws_gui_menu->ws_gui_menu_bookmarks =
 352                 gtk_menu_item_new_with_label(_("ws_me_bookmarks"));
 353         ws_gui_app->ws_gui_menu->ws_gui_menu_edit =
 354                 gtk_menu_item_new_with_label(_("ws_me_edit"));
 355         ws_gui_app->ws_gui_menu->ws_gui_menu_view =
 356                 gtk_menu_item_new_with_label(_("ws_me_view"));
 357         ws_gui_app->ws_gui_menu->ws_gui_menu_search =
 358                 gtk_menu_item_new_with_label(_("ws_me_search"));
 359         ws_gui_app->ws_gui_menu->ws_gui_menu_about =
 360                 gtk_menu_item_new_with_label(_("ws_me_about"));
 361         ws_gui_app->ws_gui_menu->ws_gui_menu_close =
 362                 gtk_menu_item_new_with_label(_("ws_me_close"));
 363         ws_gui_app->ws_gui_menu->ws_gui_separator =
 364                 gtk_separator_menu_item_new();
 365         ws_gui_app->ws_gui_menu->ws_gui_separator1 =
 366                 gtk_separator_menu_item_new();
 367
 368         ws_gui_app->ws_gui_menu->ws_gui_menu_load_dict =
 369                 gtk_menu_item_new_with_label(_("ws_me_dictionaries_load"));
 370         ws_gui_app->ws_gui_menu->ws_gui_menu_select_dict =
 371                 gtk_menu_item_new_with_label(_("ws_me_dictionaries_select"));
 372         ws_gui_app->ws_gui_menu->ws_gui_menu_remove_dict =
 373                 gtk_menu_item_new_with_label(_("ws_me_dictionaries_remove"));
 374         ws_gui_app->ws_gui_menu->ws_gui_menu_optimize_dict =
 375                 gtk_menu_item_new_with_label(_("ws_me_dictionaries_optimize"));
 376
 377         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_0,
 378                         ws_gui_app->ws_gui_menu->ws_gui_menu_load_dict);
 379         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_0,
 380                         ws_gui_app->ws_gui_menu->ws_gui_menu_select_dict);
 381         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_0,
 382                         ws_gui_app->ws_gui_menu->ws_gui_menu_remove_dict);
 383         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_0,
 384                         ws_gui_app->ws_gui_menu->ws_gui_menu_optimize_dict);
 385
 386         ws_gui_app->ws_gui_menu->ws_gui_menu_open_bookmark =
 387                 gtk_menu_item_new_with_label(_("ws_me_bookmarks_open"));
 388         ws_gui_app->ws_gui_menu->ws_gui_menu_close_bookmark =
 389                 gtk_menu_item_new_with_label(_("ws_me_bookmarks_close"));
 390         ws_gui_app->ws_gui_menu->ws_gui_menu_add_bookmark =
 391                 gtk_menu_item_new_with_label(_("ws_me_bookmarks_add"));
 392         ws_gui_app->ws_gui_menu->ws_gui_menu_remove_bookmark =
 393                 gtk_menu_item_new_with_label(_("ws_me_bookmarks_remove"));
 394
 395         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_4,
 396                         ws_gui_app->ws_gui_menu->ws_gui_menu_open_bookmark);
 397         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_4,
 398                         ws_gui_app->ws_gui_menu->ws_gui_menu_close_bookmark);
 399         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_4,
 400                         ws_gui_app->ws_gui_menu->ws_gui_menu_add_bookmark);
 401         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_4,
 402                         ws_gui_app->ws_gui_menu->ws_gui_menu_remove_bookmark);
 403
 404         ws_gui_app->ws_gui_menu->ws_gui_menu_copy =
 405                 gtk_menu_item_new_with_label(_("ws_me_edit_copy"));
 406         ws_gui_app->ws_gui_menu->ws_gui_menu_paste =
 407                 gtk_menu_item_new_with_label(_("ws_me_edit_paste"));
 408         ws_gui_app->ws_gui_menu->ws_gui_menu_select_all =
 409                 gtk_menu_item_new_with_label(_("ws_me_edit_select_all"));
 410         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_1,
 411                         ws_gui_app->ws_gui_menu->ws_gui_menu_copy);
 412         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_1,
 413                         ws_gui_app->ws_gui_menu->ws_gui_menu_paste);
 414         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_1,
 415                         ws_gui_app->ws_gui_menu->ws_gui_menu_select_all);
 416
 417         ws_gui_app->ws_gui_menu->ws_gui_menu_hide_list =
 418             gtk_check_menu_item_new_with_label(_("ws_me_view_hide_words_list"));
 419         ws_gui_app->ws_gui_menu->ws_gui_menu_zoom_in =
 420                 gtk_menu_item_new_with_label(_("ws_me_view_zoom_in"));
 421         ws_gui_app->ws_gui_menu->ws_gui_menu_zoom_out =
 422                 gtk_menu_item_new_with_label(_("ws_me_view_zoom_out"));
 423         ws_gui_app->ws_gui_menu->ws_gui_menu_full_screen =
 424                 gtk_check_menu_item_new_with_label(_("ws_me_view_fullscreen"));
 425         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_2,
 426                         ws_gui_app->ws_gui_menu->ws_gui_menu_hide_list);
 427         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_2,
 428                         ws_gui_app->ws_gui_menu->ws_gui_menu_zoom_in);
 429         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_2,
 430                         ws_gui_app->ws_gui_menu->ws_gui_menu_zoom_out);
 431         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_2,
 432                         ws_gui_app->ws_gui_menu->ws_gui_menu_full_screen);
 433
 434         ws_gui_app->ws_gui_menu->ws_gui_menu_find_word =
 435                 gtk_menu_item_new_with_label(_("ws_me_search_find"));
 436         ws_gui_app->ws_gui_menu->ws_gui_menu_find_next =
 437                 gtk_menu_item_new_with_label(_("ws_me_search_find_next"));
 438         ws_gui_app->ws_gui_menu->ws_gui_menu_find_prev =
 439                gtk_menu_item_new_with_label(_("ws_me_search_find_prev"));
 440         ws_gui_app->ws_gui_menu->ws_gui_menu_stop =
 441                gtk_menu_item_new_with_label(_("ws_me_search_stop"));
 442         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_3,
 443                        ws_gui_app->ws_gui_menu->ws_gui_menu_find_word);
 444         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_3,
 445                        ws_gui_app->ws_gui_menu->ws_gui_menu_find_next);
 446         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_3,
 447                        ws_gui_app->ws_gui_menu->ws_gui_menu_find_prev);
 448         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_submenu_3,
 449                        ws_gui_app->ws_gui_menu->ws_gui_menu_stop);
 450
 451
 452         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 453                        ws_gui_app->ws_gui_menu->ws_gui_menu_dictionaries);
 454         gtk_menu_item_set_submenu(GTK_MENU_ITEM
 455                             (ws_gui_app->ws_gui_menu->ws_gui_menu_dictionaries),
 456                              ws_gui_app->ws_gui_menu->ws_gui_submenu_0);
 457
 458         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 459                        ws_gui_app->ws_gui_menu->ws_gui_menu_bookmarks);
 460         gtk_menu_item_set_submenu(GTK_MENU_ITEM
 461                             (ws_gui_app->ws_gui_menu->ws_gui_menu_bookmarks),
 462                              ws_gui_app->ws_gui_menu->ws_gui_submenu_4);
 463
 464         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 465                        ws_gui_app->ws_gui_menu->ws_gui_separator1);
 466
 467         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 468                        ws_gui_app->ws_gui_menu->ws_gui_menu_edit);
 469         gtk_menu_item_set_submenu(GTK_MENU_ITEM
 470                                  (ws_gui_app->ws_gui_menu->ws_gui_menu_edit),
 471                                  ws_gui_app->ws_gui_menu->ws_gui_submenu_1);
 472
 473         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 474                         ws_gui_app->ws_gui_menu->ws_gui_menu_view);
 475         gtk_menu_item_set_submenu(GTK_MENU_ITEM
 476                                   (ws_gui_app->ws_gui_menu->ws_gui_menu_view),
 477                                   ws_gui_app->ws_gui_menu->ws_gui_submenu_2);
 478
 479         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 480                         ws_gui_app->ws_gui_menu->ws_gui_menu_search);
 481         gtk_menu_item_set_submenu(GTK_MENU_ITEM
 482                                   (ws_gui_app->ws_gui_menu->ws_gui_menu_search),
 483                                   ws_gui_app->ws_gui_menu->ws_gui_submenu_3);
 484
 485         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 486                         ws_gui_app->ws_gui_menu->ws_gui_separator);
 487         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 488                         ws_gui_app->ws_gui_menu->ws_gui_menu_about);
 489         gtk_menu_append(ws_gui_app->ws_gui_menu->ws_gui_main_menu,
 490                         ws_gui_app->ws_gui_menu->ws_gui_menu_close);
 491
 492         g_signal_connect(G_OBJECT
 493                          (ws_gui_app->ws_gui_menu->ws_gui_menu_load_dict),
 494                          "activate",
 495                          G_CALLBACK(ws_gui_dictionary_loader),
 496                          ws_gui_app);
 497         g_signal_connect(G_OBJECT(
 498                          ws_gui_app->ws_gui_menu->ws_gui_menu_select_dict),
 499                          "activate",
 500                          G_CALLBACK(ws_gui_dictionary_chooser),
 501                          ws_gui_app);
 502         g_signal_connect(G_OBJECT
 503                          (ws_gui_app->ws_gui_menu->ws_gui_menu_remove_dict),
 504                          "activate",
 505                          G_CALLBACK(ws_gui_dictionary_remover),
 506                          ws_gui_app);
 507         g_signal_connect(G_OBJECT
 508                          (ws_gui_app->ws_gui_menu->ws_gui_menu_optimize_dict),
 509                          "activate",
 510                          G_CALLBACK(ws_gui_dictionary_optimizer), ws_gui_app);
 511         g_signal_connect(G_OBJECT
 512                          (ws_gui_app->ws_gui_menu->ws_gui_menu_open_bookmark),
 513                          "activate",
 514                          G_CALLBACK(ws_gui_dictionary_open_bookmark),
 515                          ws_gui_app);
 516         g_signal_connect(G_OBJECT
 517                          (ws_gui_app->ws_gui_menu->ws_gui_menu_close_bookmark),
 518                          "activate",
 519                          G_CALLBACK(ws_gui_dictionary_close_bookmark),
 520                          ws_gui_app);
 521         g_signal_connect(G_OBJECT
 522                          (ws_gui_app->ws_gui_menu->ws_gui_menu_add_bookmark),
 523                          "activate",
 524                          G_CALLBACK(ws_gui_dictionary_add_bookmark),
 525                          ws_gui_app);
 526         g_signal_connect(G_OBJECT
 527                          (ws_gui_app->ws_gui_menu->ws_gui_menu_remove_bookmark),
 528                          "activate",
 529                          G_CALLBACK(ws_gui_dictionary_remove_bookmark),
 530                          ws_gui_app);
 531         g_signal_connect(G_OBJECT
 532                          (ws_gui_app->ws_gui_menu->ws_gui_menu_copy),
 533                          "activate",
 534                          GTK_SIGNAL_FUNC(ws_gui_html_copy),
 535                          ws_gui_app);
 536         g_signal_connect(G_OBJECT
 537                          (ws_gui_app->ws_gui_menu->ws_gui_menu_paste),
 538                          "activate",
 539                          GTK_SIGNAL_FUNC(ws_gui_html_paste),
 540                          ws_gui_app);
 541         g_signal_connect(G_OBJECT
 542                          (ws_gui_app->ws_gui_menu->ws_gui_menu_select_all),
 543                          "activate",
 544                          GTK_SIGNAL_FUNC(ws_gui_html_select_all),
 545                          ws_gui_app);
 546         g_signal_connect(G_OBJECT
 547                         (ws_gui_app->ws_gui_menu->ws_gui_menu_hide_list),
 548                          "activate",
 549                          GTK_SIGNAL_FUNC(ws_gui_words_list_hide_from_menu),
 550                          ws_gui_app);
 551         g_signal_connect(G_OBJECT
 552                          (ws_gui_app->ws_gui_menu->ws_gui_menu_zoom_in),
 553                          "activate",
 554                          G_CALLBACK(ws_gui_html_zoom_in),
 555                          ws_gui_app);
 556         g_signal_connect(G_OBJECT
 557                          (ws_gui_app->ws_gui_menu->ws_gui_menu_zoom_out),
 558                          "activate",
 559                          G_CALLBACK(ws_gui_html_zoom_out),
 560                          ws_gui_app);
 561         g_signal_connect(G_OBJECT
 562                          (ws_gui_app->ws_gui_menu->ws_gui_menu_full_screen),
 563                          "activate",
 564                          GTK_SIGNAL_FUNC(ws_gui_full_screen),
 565                          ws_gui_app);
 566         g_signal_connect(G_OBJECT
 567                          (ws_gui_app->ws_gui_menu->ws_gui_menu_find_word),
 568                          "activate",
 569                          GTK_SIGNAL_FUNC(ws_gui_search),
 570                          ws_gui_app);
 571         g_signal_connect(G_OBJECT
 572                          (ws_gui_app->ws_gui_menu->ws_gui_menu_find_next),
 573                          "activate",
 574                          GTK_SIGNAL_FUNC(ws_gui_history_next),
 575                          ws_gui_app);
 576         g_signal_connect(G_OBJECT
 577                          (ws_gui_app->ws_gui_menu->ws_gui_menu_find_prev),
 578                          "activate",
 579                          GTK_SIGNAL_FUNC(ws_gui_history_back),
 580                          ws_gui_app);
 581         g_signal_connect(G_OBJECT
 582                          (ws_gui_app->ws_gui_menu->ws_gui_menu_stop),
 583                          "activate",
 584                          GTK_SIGNAL_FUNC(ws_gui_search_stop),
 585                          ws_gui_app);
 586         g_signal_connect(G_OBJECT
 587                          (ws_gui_app->ws_gui_menu->ws_gui_menu_about),
 588                          "activate",
 589                          G_CALLBACK(ws_gui_about_application),
 590                          ws_gui_app);
 591         g_signal_connect(G_OBJECT
 592                          (ws_gui_app->ws_gui_menu->ws_gui_menu_close),
 593                          "activate",
 594                          G_CALLBACK(ws_gui_menu_quit),
 595                          ws_gui_app);
 596
 597         g_signal_connect(G_OBJECT
 598                          (ws_gui_app->ws_gui_menu->ws_gui_menu_edit),
 599                          "activate",
 600                          GTK_SIGNAL_FUNC(ws_gui_check_clipboard),
 601                          ws_gui_app);
 602
 603         g_signal_connect(G_OBJECT
 604                          (ws_gui_app->ws_gui_menu->ws_gui_menu_dictionaries),
 605                          "activate",
 606                          GTK_SIGNAL_FUNC(ws_gui_dict_availablity),
 607                          ws_gui_app);
 608
 609         g_signal_connect(G_OBJECT
 610                          (ws_gui_app->ws_gui_menu->ws_gui_menu_bookmarks),
 611                          "activate",
 612                          GTK_SIGNAL_FUNC(ws_gui_set_bookmark_menu_items),
 613                          ws_gui_app);
 614
 615         hildon_window_set_menu(HILDON_WINDOW(ws_gui_app->ws_gui_hildon_window),
 616                                GTK_MENU(
 617                                     ws_gui_app->ws_gui_menu->ws_gui_main_menu));
 618
 619         gtk_widget_set_sensitive(GTK_WIDGET
 620                                  (ws_gui_app->ws_gui_menu->ws_gui_menu_stop),
 621                                  FALSE);
 622         gtk_widget_set_sensitive(GTK_WIDGET
 623                                (ws_gui_app->ws_gui_menu->ws_gui_menu_find_next),
 624                                FALSE);
 625         gtk_widget_set_sensitive(GTK_WIDGET
 626                                (ws_gui_app->ws_gui_menu->ws_gui_menu_find_prev),
 627                                FALSE);
 628
 629
 630
 631         gtk_widget_show_all(ws_gui_app->ws_gui_menu->ws_gui_main_menu);
 632 }
 633
 634
 635 /** this function creates contex popup menu and its items and connect signals to
 636  * them
 637  *
 638  * @param user_data - set when the signal handler was connected
 639  */
 640 void ws_gui_create_popup_menu (gpointer user_data)
 641 {
 642         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
 643
 644         ws_gui_app->ws_gui_menu->ws_gui_popup_menu = gtk_menu_new();
 645         ws_gui_app->ws_gui_menu->ws_gui_popup_submenu = gtk_menu_new();
 646         ws_gui_app->ws_gui_menu->ws_gui_separator =
 647                                                 gtk_separator_menu_item_new();
 648
 649         ws_gui_app->ws_gui_menu->ws_gui_popup_search =
 650                 gtk_menu_item_new_with_label(_("ws_mp_search"));
 651         gtk_menu_append((ws_gui_app->ws_gui_menu->ws_gui_popup_menu),
 652                         ws_gui_app->ws_gui_menu->ws_gui_popup_search);
 653         gtk_menu_append ((ws_gui_app->ws_gui_menu->ws_gui_popup_menu),
 654                         gtk_separator_menu_item_new());
 655         ws_gui_app->ws_gui_menu->ws_gui_popup_bookmark =
 656                 gtk_menu_item_new_with_label(_("ws_mp_add_bookmark"));
 657         gtk_menu_append ((ws_gui_app->ws_gui_menu->ws_gui_popup_menu),
 658                         ws_gui_app->ws_gui_menu->ws_gui_popup_bookmark);
 659
 660         ws_gui_app->ws_gui_menu->ws_gui_popup_copy =
 661                 gtk_menu_item_new_with_label(_("ws_mp_edit_copy"));
 662         gtk_menu_append((ws_gui_app->ws_gui_menu->ws_gui_popup_submenu),
 663                         ws_gui_app->ws_gui_menu->ws_gui_popup_copy);
 664
 665         ws_gui_app->ws_gui_menu->ws_gui_popup_paste =
 666                 gtk_menu_item_new_with_label(_("ws_mp_edit_paste"));
 667         gtk_menu_append((ws_gui_app->ws_gui_menu->ws_gui_popup_submenu),
 668                         ws_gui_app->ws_gui_menu->ws_gui_popup_paste);
 669
 670         ws_gui_app->ws_gui_menu->ws_gui_popup_select_all =
 671                 gtk_menu_item_new_with_label(_("ws_mp_edit_select_all"));
 672         gtk_menu_append((ws_gui_app->ws_gui_menu->ws_gui_popup_submenu),
 673                         ws_gui_app->ws_gui_menu->ws_gui_popup_select_all);
 674
 675         gtk_widget_show_all(ws_gui_app->ws_gui_menu->ws_gui_popup_submenu);
 676
 677         ws_gui_app->ws_gui_menu->ws_gui_popup_edit =
 678                         gtk_menu_item_new_with_label (_("ws_mp_edit"));
 679         gtk_menu_append ((ws_gui_app->ws_gui_menu->ws_gui_popup_menu),
 680                         ws_gui_app->ws_gui_menu->ws_gui_popup_edit);
 681
 682         gtk_menu_append ((ws_gui_app->ws_gui_menu->ws_gui_popup_menu),
 683                         ws_gui_app->ws_gui_menu->ws_gui_separator);
 684
 685         ws_gui_app->ws_gui_menu->ws_gui_popup_zoom_in =
 686                 gtk_menu_item_new_with_label (_("ws_mp_zoom_in"));
 687         gtk_menu_append ((ws_gui_app->ws_gui_menu->ws_gui_popup_menu),
 688                         ws_gui_app->ws_gui_menu->ws_gui_popup_zoom_in);
 689
 690         ws_gui_app->ws_gui_menu->ws_gui_popup_zoom_out =
 691                 gtk_menu_item_new_with_label (_("ws_mp_zoom_out"));
 692         gtk_menu_append ((ws_gui_app->ws_gui_menu->ws_gui_popup_menu),
 693                         ws_gui_app->ws_gui_menu->ws_gui_popup_zoom_out);
 694
 695         gtk_menu_item_set_submenu(GTK_MENU_ITEM
 696                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_edit),
 697                                 ws_gui_app->ws_gui_menu->ws_gui_popup_submenu);
 698
 699         struct _GtkHTML *tmp = (struct _GtkHTML *)(ws_gui_app->ws_gui_html);
 700
 701         if (html_engine_is_selection_active(tmp->engine) == TRUE)
 702         {
 703                 gtk_widget_set_sensitive(GTK_WIDGET
 704                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_search),
 705                                 TRUE);
 706                 gtk_widget_set_sensitive(GTK_WIDGET
 707                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_copy),
 708                                 TRUE);
 709         }
 710         else
 711         {
 712                 gtk_widget_set_sensitive(GTK_WIDGET
 713                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_search),
 714                                 FALSE);
 715                 gtk_widget_set_sensitive(GTK_WIDGET
 716                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_copy),
 717                                 FALSE);
 718         }
 719
 720         if (ws_gui_app->html_flag == FALSE)
 721         {
 722                 gtk_widget_set_sensitive(GTK_WIDGET
 723                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_select_all),
 724                                 FALSE);
 725         }
 726         else
 727         {
 728                 gtk_widget_set_sensitive(GTK_WIDGET
 729                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_select_all),
 730                                 TRUE);
 731         }
 732
 733         gtk_widget_show_all(ws_gui_app->ws_gui_menu->ws_gui_popup_menu);
 734
 735
 736         g_signal_connect(G_OBJECT
 737                         (ws_gui_app->ws_gui_menu->ws_gui_popup_search),
 738                         "activate",
 739                         G_CALLBACK(ws_gui_popup_search),
 740                         ws_gui_app);
 741
 742         g_signal_connect(G_OBJECT
 743                         (ws_gui_app->ws_gui_menu->ws_gui_popup_bookmark),
 744                         "activate",
 745                         G_CALLBACK(ws_gui_dictionary_add_bookmark),
 746                         ws_gui_app);
 747
 748         g_signal_connect(G_OBJECT
 749                         (ws_gui_app->ws_gui_menu->ws_gui_popup_copy),
 750                         "activate",
 751                         G_CALLBACK(ws_gui_html_copy),
 752                         ws_gui_app);
 753         g_signal_connect(G_OBJECT
 754                         (ws_gui_app->ws_gui_menu->ws_gui_popup_paste),
 755                         "activate",
 756                         G_CALLBACK(ws_gui_html_paste),
 757                         ws_gui_app);
 758         g_signal_connect(G_OBJECT
 759                         (ws_gui_app->ws_gui_menu->ws_gui_popup_select_all),
 760                         "activate",
 761                         G_CALLBACK(ws_gui_html_select_all),
 762                         ws_gui_app);
 763         g_signal_connect(G_OBJECT
 764                         (ws_gui_app->ws_gui_menu->ws_gui_popup_zoom_in),
 765                         "activate",
 766                         G_CALLBACK(ws_gui_html_zoom_in), ws_gui_app);
 767         g_signal_connect(G_OBJECT
 768                         (ws_gui_app->ws_gui_menu->ws_gui_popup_zoom_out),
 769                         "activate",
 770                         G_CALLBACK(ws_gui_html_zoom_out),
 771                         ws_gui_app);
 772
 773         if (gtk_clipboard_wait_for_text(ws_gui_app->ws_gui_clipboard) != NULL)
 774         {
 775                 gtk_widget_set_sensitive(GTK_WIDGET
 776                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_paste),
 777                                 TRUE);
 778         }
 779         else
 780         {
 781                 gtk_widget_set_sensitive(GTK_WIDGET
 782                                 (ws_gui_app->ws_gui_menu->ws_gui_popup_paste),
 783                                 FALSE);
 784         }
 785
 786
 787         if (ws_gui_app->bookmark_avail == FALSE)
 788         {
 789         gtk_widget_set_sensitive(GTK_WIDGET
 790                         (ws_gui_app->ws_gui_menu->ws_gui_popup_bookmark),
 791                         FALSE);
 792         }
 793
 794         else
 795         {
 796         if (ws_gui_app->bookmark_mode == TRUE)
 797         {
 798                 gtk_widget_set_sensitive(GTK_WIDGET
 799                         (ws_gui_app->ws_gui_menu->ws_gui_popup_bookmark),
 800                         FALSE);
 801         }
 802         else
 803         {
 804                 g_strstrip(ws_gui_app->last_word);
 805                 //g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "\n\nlast_word: %s\n\n", ws_gui_app->last_word);
 806
 807                 if (ws_gui_app->last_word == NULL ||
 808                     (ws_gui_app->last_word[0] == '\0'))
 809                 {
 810                         gtk_widget_set_sensitive(GTK_WIDGET
 811                         (ws_gui_app->ws_gui_menu->ws_gui_popup_bookmark),
 812                         FALSE);
 813                 }
 814                 else
 815                 {
 816                         gtk_widget_set_sensitive(GTK_WIDGET
 817                         (ws_gui_app->ws_gui_menu->ws_gui_popup_bookmark),
 818                         TRUE);
 819                 }
 820         }
 821         }
 822         gtk_menu_popup(GTK_MENU(ws_gui_app->ws_gui_menu->ws_gui_popup_menu),
 823                         NULL,
 824                         NULL,
 825                         NULL,
 826                         ws_gui_app,
 827                         0,
 828                         0);
 829 }
 830
 831 /** this function creates dialog popup window and allows to select dictionaries
 832  *  which user wants to use
 833  *
 834  * @param menuitem - the object which received the signal
 835  * @param user_data - set when the signal handler was connected
 836  */
 837 void ws_gui_dictionary_chooser(GtkMenuItem *menuitem, gpointer user_data)
 838 {
 839         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
 840         GtkWidget *dialog1;
 841         GtkWidget *dialog_vbox1;
 842         GtkWidget *scrolledwindow1;
 843         GtkWidget *viewport1;
 844         GtkWidget *vbox1;
 845
 846         GtkWidget *checkbutton;
 847         GtkWidget *cancel_button;
 848         GtkWidget *ok_button;
 849         guint i =0;
 850         gchar* string;
 851         gchar* path;
 852         const gchar* name;
 853         GArray *checkboxes;
 854
 855         checkboxes = g_array_new (TRUE, TRUE, sizeof(GtkWidget*));
 856
 857         if (gconf_client_dir_exists(ws_gui_app->client,
 858                                     GCONF_PATH, NULL) == TRUE)
 859         {
 860                ws_gui_app->directories =
 861                        gconf_client_all_dirs(ws_gui_app->client,
 862                                              GCONF_PATH,
 863                                              NULL);
 864         }
 865         else
 866         {
 867                g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO,
 868                   "\n.::GUI::. /apps/WhiteStork/Dictionaries does not exist!!");
 869         }
 870
 871         dialog1 = gtk_dialog_new ();
 872         gtk_window_set_title (GTK_WINDOW (dialog1),
 873                              (_("ws_ti_choose_dictionaries_title")));
 874         gtk_window_set_type_hint (GTK_WINDOW (dialog1),
 875                                   GDK_WINDOW_TYPE_HINT_DIALOG);
 876         gtk_window_set_default_size(GTK_WINDOW (dialog1), 300, 200);
 877
 878         dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
 879         gtk_widget_show (dialog_vbox1);
 880
 881         scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
 882         gtk_widget_show (scrolledwindow1);
 883         gtk_box_pack_start (GTK_BOX (dialog_vbox1),
 884                             scrolledwindow1,
 885                             TRUE,
 886                             TRUE,
 887                             0);
 888
 889         viewport1 = gtk_viewport_new (NULL, NULL);
 890         gtk_widget_show (viewport1);
 891         gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport1);
 892
 893         vbox1 = gtk_vbox_new (FALSE, 0);
 894         gtk_widget_show (vbox1);
 895         gtk_container_add (GTK_CONTAINER (viewport1), vbox1);
 896
 897         for (i=0; i< g_slist_length(ws_gui_app->directories);i++)
 898         {
 899                string = (gchar*)g_slist_nth_data(ws_gui_app->directories, i);
 900                name = g_path_get_basename(string);
 901                checkbutton = gtk_check_button_new_with_label(name);
 902                path = g_strconcat(string, "/active", NULL);
 903
 904                if (gconf_client_get_bool(ws_gui_app->client,
 905                                          path,
 906                                          NULL) == TRUE)
 907                {
 908                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(
 909                                                     checkbutton),
 910                                                     TRUE);
 911                }
 912                else
 913                {
 914                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(
 915                                                     checkbutton),
 916                                                     FALSE);
 917                }
 918
 919                 g_array_append_val(checkboxes, checkbutton);
 920                 gtk_box_pack_start (GTK_BOX (vbox1),
 921                                    checkbutton,
 922                                    FALSE,
 923                                    FALSE,
 924                                    0);
 925
 926                 if (strcmp(name, "bookmarks") == 0)
 927                 {
 928                         if (ws_gui_app->bookmark_avail == FALSE)
 929                         {
 930                         gtk_widget_set_sensitive(GTK_WIDGET(checkbutton),
 931                                                  FALSE);
 932                         }
 933                 }
 934
 935                 gtk_widget_show (checkbutton);
 936         }
 937
 938         cancel_button = gtk_button_new_from_stock (_("ws_db_cancel"));
 939         gtk_widget_show (cancel_button);
 940         gtk_dialog_add_action_widget (GTK_DIALOG (dialog1),
 941                                         cancel_button,
 942                                         GTK_RESPONSE_CANCEL);
 943
 944         ok_button = gtk_button_new_from_stock (_("ws_db_ok"));
 945         gtk_widget_show (ok_button);
 946         gtk_dialog_add_action_widget(GTK_DIALOG (dialog1),
 947                                         ok_button,
 948                                         GTK_RESPONSE_OK);
 949
 950         i = gtk_dialog_run(GTK_DIALOG(dialog1));
 951
 952         if (i == GTK_RESPONSE_OK)
 953         {
 954                 for(i=0;i<(checkboxes->len);i++)
 955                 {
 956                         if (gtk_toggle_button_get_active(
 957                                 GTK_TOGGLE_BUTTON(g_array_index(checkboxes,
 958                                                 GtkWidget *, i))) == TRUE)
 959                         {
 960                                 name = gtk_button_get_label(GTK_BUTTON(
 961                                 g_array_index(checkboxes, GtkWidget *, i)));
 962
 963                                 path=g_strconcat(GCONF_PATH,
 964                                                 "/",
 965                                                 name,
 966                                                 "/active",
 967                                                 NULL);
 968                                 gconf_client_set_bool(ws_gui_app->client,
 969                                                         path,
 970                                                         TRUE,
 971                                                         NULL);
 972                         }
 973
 974                         if (gtk_toggle_button_get_active(
 975                                 GTK_TOGGLE_BUTTON(g_array_index(checkboxes,
 976                                                 GtkWidget *, i))) == FALSE)
 977                         {
 978                                 name = gtk_button_get_label(GTK_BUTTON(
 979                                 g_array_index(checkboxes, GtkWidget *, i)));
 980
 981                                 path=g_strconcat(GCONF_PATH,
 982                                                 "/",
 983                                                 name,
 984                                                 "/active",
 985                                                 NULL);
 986                                 gconf_client_set_bool(ws_gui_app->client,
 987                                                         path,
 988                                                         FALSE,
 989                                                         NULL);
 990                         }
 991                 }
 992
 993                 ws_dbus_notify(ws_gui_app->dbus_data,
 994                                 WS_DBUS_INFO_CONFIG_CHANGED);
 995
 996                 if(ws_gui_app->ws_gui_history->len >= 0)
 997                 {
 998                 ws_gui_clear_array(ws_gui_app->ws_gui_history);
 999                 ws_gui_clear_array(ws_gui_app->ws_gui_history_list);
1000                 ws_gui_clear_array(ws_gui_app->ws_gui_history_iter);
1001                 ws_gui_app->ws_gui_history_cur_pos = -1;
1002                 }
1003                 ws_gui_check_history(ws_gui_app);
1004
1005                 gtk_widget_destroy (dialog1);
1006         }
1007         else if (i == GTK_RESPONSE_CANCEL)
1008         {
1009                 gtk_widget_destroy (dialog1);
1010         }
1011
1012         g_slist_free(ws_gui_app->directories);
1013 }
1014
1015 /** this function creates dialog popup window and allows optimize dictionaries
1016  *
1017  * @param menuitem - the object which received the signal
1018  * @param user_data - set when the signal handler was connected
1019  */
1020 void ws_gui_dictionary_optimizer(GtkMenuItem *menuitem, gpointer user_data)
1021 {
1022         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
1023
1024         GtkWidget *dialog1;
1025         GtkWidget *dialog_vbox1;
1026         GtkWidget *scrolledwindow1;
1027         GtkWidget *viewport1;
1028         GtkWidget *vbox1;
1029
1030         GtkWidget *checkbutton;
1031         GtkWidget *cancel_button;
1032         GtkWidget *ok_button;
1033         guint i =0;
1034         gchar* string;
1035         gchar* path;
1036         const gchar* name;
1037         GArray *checkboxes;
1038
1039         checkboxes = g_array_new (TRUE, TRUE, sizeof(GtkWidget*));
1040
1041         if (gconf_client_dir_exists(ws_gui_app->client,
1042                                     GCONF_PATH,
1043                                     NULL) == TRUE)
1044         {
1045                 ws_gui_app->directories =
1046                     gconf_client_all_dirs(ws_gui_app->client, GCONF_PATH, NULL);
1047         }
1048         else
1049         {
1050                 g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO,
1051                   "\n.::GUI::. /apps/WhiteStork/Dictionaries does not exist!!");
1052         }
1053
1054         for (i=0; i< g_slist_length(ws_gui_app->directories);i++)
1055         {
1056                 string = (gchar*)g_slist_nth_data(ws_gui_app->directories, i);
1057                 name = g_path_get_basename(string);
1058
1059                 path = g_strconcat(string, "/optimized", NULL);
1060                 if (gconf_client_get_bool (ws_gui_app->client,
1061                                            path,
1062                                            NULL) == FALSE)
1063                 {
1064                         checkbutton = gtk_check_button_new_with_label(name);
1065                         g_array_append_val(checkboxes, checkbutton);
1066                 }
1067         }
1068         if (checkboxes->len <= 0)
1069         {
1070                 ws_gui_app->ws_message_dialog = gtk_message_dialog_new(
1071                                    GTK_WINDOW(ws_gui_app->ws_gui_hildon_window),
1072                                    GTK_DIALOG_DESTROY_WITH_PARENT,
1073                                    GTK_MESSAGE_ERROR,
1074                                    GTK_BUTTONS_OK,
1075                                    _("ws_ni_no_dictionaries_to_optimize"));
1076                gtk_widget_show_all(ws_gui_app->ws_message_dialog);
1077                if (gtk_dialog_run (GTK_DIALOG (
1078                         ws_gui_app->ws_message_dialog)) == GTK_RESPONSE_OK)
1079                {
1080                         gtk_widget_destroy(ws_gui_app->ws_message_dialog);
1081                }
1082         }
1083         else
1084         {
1085                 dialog1 = gtk_dialog_new ();
1086                 gtk_window_set_title(GTK_WINDOW (dialog1),
1087                                      (_("ws_ti_choose_dictionaries_title")));
1088                 gtk_window_set_type_hint(GTK_WINDOW (dialog1),
1089                                          GDK_WINDOW_TYPE_HINT_DIALOG);
1090                 gtk_window_set_default_size(GTK_WINDOW (dialog1), 300, 200);
1091
1092                 dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
1093                 gtk_widget_show (dialog_vbox1);
1094
1095                 scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
1096                 gtk_widget_show (scrolledwindow1);
1097                 gtk_box_pack_start(GTK_BOX (dialog_vbox1),
1098                                    scrolledwindow1,
1099                                    TRUE,
1100                                    TRUE,
1101                                    0);
1102
1103                 viewport1 = gtk_viewport_new (NULL, NULL);
1104                 gtk_widget_show (viewport1);
1105                 gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport1);
1106
1107                 vbox1 = gtk_vbox_new (FALSE, 0);
1108                 gtk_widget_show (vbox1);
1109                 gtk_container_add (GTK_CONTAINER (viewport1), vbox1);
1110                 for (i=0; i<checkboxes->len; i++)
1111                 {
1112                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(
1113                                       g_array_index(checkboxes, GtkWidget*, i)),
1114                                       FALSE);
1115                         gtk_box_pack_start(GTK_BOX (vbox1),
1116                                        g_array_index(checkboxes, GtkWidget*, i),
1117                                        FALSE,
1118                                        FALSE,
1119                                        0);
1120                         gtk_widget_show(g_array_index(checkboxes,
1121                                                       GtkWidget*,
1122                                                       i));
1123                 }
1124                 cancel_button = gtk_button_new_from_stock (_("ws_db_cancel"));
1125                 gtk_widget_show (cancel_button);
1126                 gtk_dialog_add_action_widget(GTK_DIALOG (dialog1),
1127                                              cancel_button,
1128                                              GTK_RESPONSE_CANCEL);
1129                 ok_button = gtk_button_new_from_stock (_("ws_db_ok"));
1130                 gtk_widget_show (ok_button);
1131                 gtk_dialog_add_action_widget(GTK_DIALOG (dialog1),
1132                                              ok_button,
1133                                              GTK_RESPONSE_OK);
1134                 i = gtk_dialog_run(GTK_DIALOG(dialog1));
1135                 if (i == GTK_RESPONSE_OK)
1136                 {
1137                         for(i=0;i<(checkboxes->len);i++)
1138                         {
1139                                 if (gtk_toggle_button_get_active(
1140                                     GTK_TOGGLE_BUTTON(
1141                                         g_array_index(checkboxes,
1142                                                 GtkWidget *, i))) == TRUE)
1143                                 {
1144                                         name = gtk_button_get_label(GTK_BUTTON(
1145                                                 g_array_index(checkboxes,
1146                                                               GtkWidget *,
1147                                                               i)));
1148                                         path=g_strconcat(GCONF_PATH,
1149                                                          "/",
1150                                                          name,
1151                                                          "/optimized",
1152                                                          NULL);
1153                                         gconf_client_set_bool(
1154                                                              ws_gui_app->client,
1155                                                              path,
1156                                                              TRUE,
1157                                                              NULL);
1158                                 }
1159                                 if (gtk_toggle_button_get_active(
1160                                      GTK_TOGGLE_BUTTON(
1161                                        g_array_index(checkboxes,
1162                                                      GtkWidget *, i))) == FALSE)
1163                                 {
1164                                         name = gtk_button_get_label(GTK_BUTTON
1165                                                       (g_array_index(checkboxes,
1166                                                                      GtkWidget*,
1167                                                                      i)));
1168                                         path=g_strconcat(GCONF_PATH,
1169                                                          "/",
1170                                                          name,
1171                                                          "/optimized",
1172                                                          NULL);
1173                                         gconf_client_set_bool(
1174                                                              ws_gui_app->client,
1175                                                              path,
1176                                                              FALSE,
1177                                                              NULL);
1178                                 }
1179                         }
1180                         ws_dbus_notify(ws_gui_app->dbus_data,
1181                                        WS_DBUS_INFO_CONFIG_CHANGED);
1182                         gtk_widget_destroy (dialog1);
1183                 }
1184                 else if (i == GTK_RESPONSE_CANCEL)
1185                 {
1186                         gtk_widget_destroy (dialog1);
1187                 }
1188         }
1189         g_slist_free(ws_gui_app->directories);
1190 }
1191
1192 /** this function creates dialog popup window which allows to load a new
1193  *dictionary file into application
1194  *
1195  * @param menuitem - the object which received the signal
1196  * @param user_data - set when the signal handler was connected
1197  */
1198 void ws_gui_dictionary_loader(GtkMenuItem *menuitem, gpointer user_data)
1199 {
1200         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
1201
1202         GtkWidget *dialog;
1203   //      GtkWidget *dialog2;
1204
1205         dialog = hildon_file_chooser_dialog_new(
1206                                 GTK_WINDOW(ws_gui_app->ws_gui_hildon_window),
1207                                 GTK_FILE_CHOOSER_ACTION_OPEN);
1208
1209         gtk_window_set_default_size(GTK_WINDOW (dialog), 200, 200);
1210         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(dialog), FALSE);
1211
1212         //gtk_widget_show(GTK_WIDGET(dialog));
1213
1214         if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
1215         {
1216                 gchar *filename;
1217                 gchar *name;
1218              //   gchar *path;
1219                 gint len;
1220               //  gchar *filepath;
1221
1222                 gchar* tmp;
1223
1224                 filename = gtk_file_chooser_get_filename(
1225                                                      GTK_FILE_CHOOSER (dialog));
1226                 name = g_path_get_basename(filename);
1227                 len = strlen(filename) - strlen(name) -1;
1228                 tmp = g_strndup (filename, len);
1229
1230
1231                 tmp = g_path_get_basename(tmp);
1232
1233                 if (g_str_has_suffix(name, ".xdxf")
1234                         || g_str_has_suffix(name, ".idx")
1235                         || g_str_has_suffix(name, ".ifo")
1236                         || g_str_has_suffix(name, ".idx.gz")
1237                         || g_str_has_suffix(name, ".dict")
1238                         || g_str_has_suffix(name, ".dict.dz"))
1239                 {
1240                         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "\n:::GUUUUIII GUIII::: check");
1241                         if (ws_gui_load_dict(filename, ws_gui_app) == TRUE)
1242                         {
1243                                 gtk_widget_destroy(dialog);
1244                                 gtk_infoprint(GTK_WINDOW(
1245                                       ws_gui_app->ws_gui_hildon_window),
1246                                       _("ws_ni_dictionary_added"));
1247                         }
1248                 }
1249                 else if (g_str_has_suffix(name, ".bz2"))
1250                 {
1251                         gtk_widget_destroy(dialog);
1252                         ws_dbus_client_extract_dictionary(ws_gui_app->dbus_data, filename);
1253                 }
1254                 else
1255                 {
1256                         gtk_widget_destroy (dialog);
1257                         gtk_infoprint(GTK_WINDOW(
1258                                       ws_gui_app->ws_gui_hildon_window),
1259                                       _("ws_ni_dictionary_wrong_file"));
1260                 }
1261
1262         }
1263         else
1264         {
1265                 gtk_widget_destroy (dialog);
1266         }
1267
1268 }
1269
1270 /** this function creates dialog popup window which allows to load dictionary
1271  *
1272  * @param filename - the object which received the signal
1273  * @param user_data - set when the signal handler was connected
1274  */
1275 gboolean ws_gui_load_dict(gchar *filename, gpointer user_data)
1276 {
1277         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
1278
1279         GtkWidget *dialog1;
1280         GtkWidget *dialog2;
1281         gchar *name = g_path_get_basename(filename);
1282         gchar *path;
1283         gint len;
1284         gchar *filepath;
1285
1286         len = strlen(filename) - strlen(name) -1;
1287         gchar *tmp = g_strndup (filename, len);;
1288         tmp = g_path_get_basename(tmp);
1289
1290
1291         filepath = g_strndup (filename, len);
1292         path = g_strconcat(GCONF_PATH, "/", tmp, "/path", NULL);
1293         gconf_client_set_string(ws_gui_app->client,
1294                                 path,
1295                                 filepath,
1296                                 NULL);
1297         g_free(path);
1298         path = NULL;
1299         path = g_strconcat(GCONF_PATH,
1300                                 "/",
1301                                 tmp,
1302                                 "/active",
1303                                 NULL);
1304
1305         dialog1 = gtk_message_dialog_new(GTK_WINDOW(
1306                                          ws_gui_app->ws_gui_hildon_window),
1307                                          GTK_DIALOG_DESTROY_WITH_PARENT,
1308                                          GTK_MESSAGE_QUESTION,
1309                                          GTK_BUTTONS_YES_NO,
1310                                 _("ws_ni_dictionaries_activation_question"));
1311
1312         gtk_widget_show_all(GTK_WIDGET(dialog1));
1313
1314         if (gtk_dialog_run (GTK_DIALOG (dialog1)) == GTK_RESPONSE_YES)
1315         {
1316                 gconf_client_set_bool(ws_gui_app->client,
1317                                         path,
1318                                         TRUE,
1319                                         NULL);
1320         }
1321         else
1322         {
1323                 gconf_client_set_bool(ws_gui_app->client,
1324                                         path,
1325                                         FALSE,
1326                                         NULL);
1327         }
1328         gtk_widget_destroy (dialog1);
1329         g_free(path);
1330         path = NULL;
1331
1332         path = g_strconcat(GCONF_PATH, "/", tmp, "/optimized", NULL);
1333
1334         dialog2 = gtk_message_dialog_new(
1335                 GTK_WINDOW(ws_gui_app->ws_gui_hildon_window),
1336                 GTK_DIALOG_DESTROY_WITH_PARENT,
1337                 GTK_MESSAGE_QUESTION,
1338                 GTK_BUTTONS_YES_NO,
1339                 _("ws_ni_dictionaries_optimalization_question"));
1340
1341         gtk_widget_show_all(GTK_WIDGET(dialog2));
1342
1343         if (gtk_dialog_run (GTK_DIALOG (dialog2)) == GTK_RESPONSE_YES)
1344         {
1345                 gconf_client_set_bool(ws_gui_app->client,
1346                                         path,
1347                                         TRUE,
1348                                         NULL);
1349         }
1350         else
1351         {
1352                 gconf_client_set_bool(ws_gui_app->client,
1353                                         path,
1354                                         FALSE,
1355                                         NULL);
1356         }
1357         gtk_widget_destroy (dialog2);
1358
1359         if(ws_gui_app->ws_gui_history->len > 0)
1360         {
1361                 ws_gui_clear_array(ws_gui_app->ws_gui_history);
1362                 ws_gui_clear_array(ws_gui_app->ws_gui_history_list);
1363                 ws_gui_clear_array(ws_gui_app->ws_gui_history_iter);
1364                 ws_gui_app->ws_gui_history_cur_pos = -1;
1365         }
1366         ws_gui_check_history(ws_gui_app);
1367
1368         ws_dbus_notify(ws_gui_app->dbus_data,
1369                                 WS_DBUS_INFO_CONFIG_CHANGED);
1370
1371         return TRUE;
1372 }
1373
1374 /** this function creates dialog popup window which allows to remove dictionary
1375  *  which is no longer used
1376  *
1377  * @param menuitem - the object which received the signal
1378  * @param user_data - set when the signal handler was connected
1379  */
1380 void ws_gui_dictionary_remover(GtkMenuItem *menuitem, gpointer user_data)
1381 {
1382         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
1383
1384         GtkWidget *dialog1;
1385         GtkWidget *dialog_vbox1;
1386         GtkWidget *scrolledwindow1;
1387         GtkWidget *viewport1;
1388         GtkWidget *vbox1;
1389         GtkWidget *checkbutton;
1390         GtkWidget *cancel_button;
1391         GtkWidget *ok_button;
1392         guint i =0;
1393         gchar* string;
1394         gchar* path;
1395         const gchar* name;
1396         GArray *checkboxes;
1397
1398         checkboxes = g_array_new (TRUE, TRUE, sizeof(GtkWidget*));
1399
1400         if (gconf_client_dir_exists(ws_gui_app->client, GCONF_PATH, NULL)
1401                                                                         == TRUE)
1402         {
1403                 ws_gui_app->directories = gconf_client_all_dirs(
1404                                                              ws_gui_app->client,
1405                                                              GCONF_PATH,
1406                                                              NULL);
1407         }
1408         else
1409         {
1410                 g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO,
1411                   "\n.::GUI::. /apps/WhiteStork/Dictionaries does not exist!!");
1412         }
1413
1414         dialog1 = gtk_dialog_new ();
1415         gtk_window_set_title (GTK_WINDOW (dialog1),
1416                              (_("ws_ti_remove_dictionaries_title")));
1417         gtk_window_set_type_hint (GTK_WINDOW (dialog1),
1418                                   GDK_WINDOW_TYPE_HINT_DIALOG);
1419         gtk_window_set_default_size(GTK_WINDOW (dialog1), 300, 200);
1420
1421         dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
1422         gtk_widget_show (dialog_vbox1);
1423
1424         scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
1425         gtk_widget_show (scrolledwindow1);
1426         gtk_box_pack_start (GTK_BOX (dialog_vbox1),
1427                             scrolledwindow1,
1428                             TRUE,
1429                             TRUE,
1430                             0);
1431
1432         viewport1 = gtk_viewport_new (NULL, NULL);
1433         gtk_widget_show (viewport1);
1434         gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport1);
1435
1436         vbox1 = gtk_vbox_new (FALSE, 0);
1437         gtk_widget_show (vbox1);
1438         gtk_container_add (GTK_CONTAINER (viewport1), vbox1);
1439
1440         for (i=0; i< g_slist_length(ws_gui_app->directories);i++)
1441         {
1442                 string = (gchar*)g_slist_nth_data(ws_gui_app->directories, i);
1443                 name = g_path_get_basename(string);
1444                 checkbutton = gtk_check_button_new_with_label(name);
1445
1446                 g_array_append_val(checkboxes, checkbutton);
1447                 gtk_box_pack_start (GTK_BOX (vbox1),
1448                                     checkbutton,
1449                                     FALSE,
1450                                     FALSE,
1451                                     0);
1452
1453                 if (strcmp(name, "bookmarks") == 0)
1454                 {
1455                    gtk_widget_set_sensitive(GTK_WIDGET(checkbutton), FALSE);
1456                 }
1457                 gtk_widget_show (checkbutton);
1458         }
1459
1460         cancel_button = gtk_button_new_from_stock (_("ws_db_cancel"));
1461         gtk_widget_show (cancel_button);
1462         gtk_dialog_add_action_widget (GTK_DIALOG (dialog1),
1463                                       cancel_button,
1464                                       GTK_RESPONSE_CANCEL);
1465
1466         ok_button = gtk_button_new_from_stock
1467                                (_("ws_bd_remove_dictionaries_remove_selected"));
1468         gtk_widget_show (ok_button);
1469         gtk_dialog_add_action_widget(GTK_DIALOG (dialog1),
1470                                      ok_button,
1471                                      GTK_RESPONSE_OK);
1472
1473         i = gtk_dialog_run(GTK_DIALOG(dialog1));
1474
1475         if (i == GTK_RESPONSE_OK)
1476         {
1477                 for(i=0;i<(checkboxes->len);i++)
1478                 {
1479                         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
1480                             g_array_index(checkboxes, GtkWidget *, i))) == TRUE)
1481                         {
1482
1483                                 name = gtk_button_get_label(GTK_BUTTON(
1484                                     g_array_index(checkboxes, GtkWidget *, i)));
1485                                 path=g_strconcat(GCONF_PATH, "/", name, NULL);
1486                                 gconf_client_recursive_unset(ws_gui_app->client,
1487                                              path,
1488                                              GCONF_UNSET_INCLUDING_SCHEMA_NAMES,
1489                                              NULL);
1490                         }
1491                  }
1492
1493                 if(ws_gui_app->ws_gui_history->len >= 0)
1494                 {
1495                         ws_gui_clear_array(ws_gui_app->ws_gui_history);
1496                         ws_gui_clear_array(ws_gui_app->ws_gui_history_list);
1497                         ws_gui_clear_array(ws_gui_app->ws_gui_history_iter);
1498                         ws_gui_app->ws_gui_history_cur_pos = -1;
1499                 }
1500                 ws_gui_check_history(ws_gui_app);
1501
1502                 ws_dbus_notify(ws_gui_app->dbus_data,
1503                                WS_DBUS_INFO_CONFIG_CHANGED);
1504                 gtk_infoprint(GTK_WINDOW(
1505                                       ws_gui_app->ws_gui_hildon_window),
1506                                       _("ws_ib_dictionary_removed"));
1507                 gtk_widget_destroy (dialog1);
1508         }
1509         else if (i == GTK_RESPONSE_CANCEL)
1510         {
1511                 gtk_widget_destroy (dialog1);
1512         }
1513
1514         g_slist_free(ws_gui_app->directories);
1515 }
1516
1517 /** this function creates dialog popup window which displays information about
1518  * application (about window)
1519  *
1520  * @param menuitem - the object which received the signal
1521  * @param user_data - set when the signal handler was connected
1522  */
1523 void ws_gui_about_application(GtkMenuItem *menuitem, gpointer user_data)
1524 {
1525         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
1526
1527         gtk_widget_set_sensitive(GTK_WIDGET
1528                                  (ws_gui_app->ws_gui_hildon_find_toolbar),
1529                                  FALSE);
1530
1531         GtkWidget *about_dialog;
1532         GtkWidget *dialog_vbox1;
1533         GtkWidget *vbox1;
1534         GtkWidget *image;
1535         GtkWidget *label2;
1536         GtkWidget *label3;
1537         GtkWidget *label4;
1538         GtkWidget *scrolledwindow;
1539         GtkWidget *textview;
1540         GtkWidget *button1;
1541
1542         const gchar *ws_version;
1543
1544         about_dialog = gtk_dialog_new ();
1545         gtk_window_set_title (GTK_WINDOW (about_dialog),
1546                               _("ws_ti_about_title"));
1547         gtk_window_set_default_size(GTK_WINDOW (about_dialog), 350, 200);
1548
1549         dialog_vbox1 = GTK_DIALOG (about_dialog)->vbox;
1550         gtk_widget_show (dialog_vbox1);
1551
1552         vbox1 = gtk_vbox_new (FALSE, 0);
1553         gtk_widget_show (vbox1);
1554         gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
1555
1556         image = gtk_image_new_from_file ("/usr/share/pixmaps/whitestork.png");
1557         gtk_box_pack_start (GTK_BOX (vbox1), image, TRUE, TRUE, 0);
1558
1559         label2 = gtk_label_new ("WhiteStork");
1560         ws_gui_app->p = pango_font_description_from_string("Tahoma 18");
1561         gtk_widget_modify_font(GTK_WIDGET(label2), ws_gui_app->p);
1562         gtk_label_set_pattern (GTK_LABEL(label2), "__________");
1563         gtk_box_pack_start (GTK_BOX (vbox1), label2, FALSE, FALSE, 5);
1564
1565         ws_version = g_strconcat("Maemo Multilingual Dictionary\nver. ",
1566                                 WS_VERSION,
1567                                 NULL);
1568         label3 = gtk_label_new_with_mnemonic (_(ws_version));
1569         ws_gui_app->p = pango_font_description_from_string("Tahoma 12");
1570         gtk_widget_modify_font(GTK_WIDGET(label3), ws_gui_app->p);
1571         gtk_box_pack_start (GTK_BOX (vbox1), label3, FALSE, FALSE, 5);
1572         gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_CENTER);
1573
1574         label4 = gtk_label_new ("Copyright 2006, ComArch S.A\nAll rights "
1575                                 "reserved");
1576         ws_gui_app->p = pango_font_description_from_string("Tahoma 12");
1577         gtk_widget_modify_font(GTK_WIDGET(label4), ws_gui_app->p);
1578         gtk_box_pack_start (GTK_BOX (vbox1), label4, FALSE, FALSE, 5);
1579         gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_CENTER);
1580
1581         scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
1582         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW
1583                                              (scrolledwindow),
1584                                              GTK_SHADOW_ETCHED_OUT);
1585         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW
1586                                         (scrolledwindow),
1587                                         GTK_POLICY_AUTOMATIC,
1588                                         GTK_POLICY_AUTOMATIC);
1589         gtk_box_pack_start (GTK_BOX (vbox1),
1590                             scrolledwindow,
1591                             TRUE,
1592                             TRUE,
1593                             0);
1594
1595         textview = gtk_text_view_new ();
1596         ws_gui_app->p = pango_font_description_from_string("Tahoma 10");
1597         gtk_widget_modify_font(GTK_WIDGET(textview), ws_gui_app->p);
1598         gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
1599         gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview), 10);
1600         gtk_text_view_set_right_margin(GTK_TEXT_VIEW(textview), 10);
1601         gtk_container_add (GTK_CONTAINER (scrolledwindow), textview);
1602         gtk_text_buffer_set_text(
1603                         gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview)),
1604                         "The following third party\ncomponents may be\nincluded"
1605                         " depending \non your system configuration:\n\nD-BUS "
1606                         "- License information:\nhttp://opensource.org/"
1607                         "licenses/academic.php",
1608                         -1);
1609
1610         button1 = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
1611         gtk_dialog_add_action_widget(GTK_DIALOG(about_dialog),
1612                                      button1,
1613                                      GTK_RESPONSE_CLOSE);
1614
1615         gtk_widget_show_all (GTK_WIDGET(about_dialog));
1616
1617         if (gtk_dialog_run(GTK_DIALOG(about_dialog)) == GTK_RESPONSE_CLOSE)
1618         {
1619                 gtk_widget_destroy(GTK_WIDGET(about_dialog));
1620         }
1621
1622         gtk_widget_set_sensitive(
1623                              GTK_WIDGET(ws_gui_app->ws_gui_hildon_find_toolbar),
1624                              TRUE);
1625 }
1626
1627 void ws_gui_add_bookmark_dialog(gpointer user_data)
1628 {
1629
1630         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
1631
1632         GtkWidget *dialog1;
1633         GtkWidget *dialog_vbox1;
1634         GtkWidget *vbox1;
1635         GtkWidget *hbox1;
1636         GtkWidget *entry1;
1637         GtkWidget *label;
1638         GtkWidget *cancelbutton1;
1639         GtkWidget *okbutton1;
1640
1641         const gchar *book_word;
1642
1643         dialog1 = gtk_dialog_new ();
1644         gtk_window_set_title (GTK_WINDOW (dialog1), _("ws_ti_add_bookmark"));
1645         gtk_window_set_default_size(GTK_WINDOW (dialog1), 300, 200);
1646
1647         dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
1648         gtk_widget_show (dialog_vbox1);
1649
1650         vbox1 = gtk_vbox_new (FALSE, 0);
1651         gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 5);
1652
1653         hbox1 = gtk_hbox_new (FALSE, 0);
1654         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 5);
1655
1656         label = gtk_label_new(_("ws_ti_bookmarks_add_question"));
1657         gtk_box_pack_start (GTK_BOX (hbox1), label, TRUE, TRUE, 5);
1658
1659         entry1 = gtk_entry_new ();
1660         gtk_box_pack_start (GTK_BOX (vbox1), entry1, TRUE, TRUE, 5);
1661         gtk_entry_set_text(GTK_ENTRY(entry1), ws_gui_app->last_word);
1662         gtk_entry_set_alignment (GTK_ENTRY(entry1), 0.5);
1663         gtk_entry_set_editable(GTK_ENTRY(entry1), TRUE);
1664
1665         cancelbutton1 = gtk_button_new_from_stock (_("ws_db_ok"));
1666         gtk_dialog_add_action_widget (GTK_DIALOG (dialog1),
1667                                       cancelbutton1,
1668                                       GTK_RESPONSE_OK);
1669
1670         okbutton1 = gtk_button_new_from_stock (_("ws_db_cancel"));
1671         gtk_dialog_add_action_widget (GTK_DIALOG (dialog1),
1672                                       okbutton1,
1673                                       GTK_RESPONSE_CANCEL);
1674
1675         gtk_widget_show_all (dialog1);
1676
1677         if (gtk_dialog_run(GTK_DIALOG(dialog1)) == GTK_RESPONSE_OK)
1678         {
1679                 book_word = gtk_entry_get_text(GTK_ENTRY(entry1));
1680                 ws_dbus_client_add_bookmark(ws_gui_app->dbus_data,
1681                                      (gchar*)book_word,
1682                                      ws_gui_app->raw_translation->str);
1683                 gtk_widget_destroy(GTK_WIDGET(dialog1));
1684
1685         }
1686         else
1687         {
1688                 gtk_widget_destroy(GTK_WIDGET(dialog1));
1689         }
1690 }
1691
1692 void ws_gui_remove_bookmark_dialog(gpointer user_data)
1693 {
1694         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
1695
1696         GtkWidget *dialog1;
1697         GtkWidget *dialog_vbox1;
1698         GtkWidget *vbox1;
1699         GtkWidget *hbox1;
1700         GtkWidget *entry1;
1701         GtkWidget *label;
1702         GtkWidget *cancelbutton1;
1703         GtkWidget *okbutton1;
1704
1705         dialog1 = gtk_dialog_new ();
1706         gtk_window_set_title (GTK_WINDOW (dialog1), _("ws_ti_remove_bookmark"));
1707         gtk_window_set_default_size(GTK_WINDOW (dialog1), 300, 200);
1708
1709         dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
1710         gtk_widget_show (dialog_vbox1);
1711
1712         vbox1 = gtk_vbox_new (FALSE, 0);
1713         gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 5);
1714
1715         hbox1 = gtk_hbox_new (FALSE, 0);
1716         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 5);
1717
1718         label = gtk_label_new(_("ws_ni_remove_bookmark_question"));
1719         gtk_box_pack_start (GTK_BOX (hbox1), label, TRUE, TRUE, 5);
1720
1721         entry1 = gtk_entry_new ();
1722         gtk_box_pack_start (GTK_BOX (vbox1), entry1, TRUE, TRUE, 5);
1723         gtk_entry_set_text(GTK_ENTRY(entry1), ws_gui_app->last_word);
1724         gtk_entry_set_alignment (GTK_ENTRY(entry1), 0.5);
1725         gtk_entry_set_editable(GTK_ENTRY(entry1), FALSE);
1726
1727         cancelbutton1 = gtk_button_new_from_stock (_("ws_db_ok"));
1728         gtk_dialog_add_action_widget (GTK_DIALOG (dialog1),
1729                                       cancelbutton1,
1730                                       GTK_RESPONSE_OK);
1731
1732         okbutton1 = gtk_button_new_from_stock (_("ws_db_cancel"));
1733         gtk_dialog_add_action_widget (GTK_DIALOG (dialog1),
1734                                       okbutton1,
1735                                       GTK_RESPONSE_CANCEL);
1736
1737         gtk_widget_show_all (dialog1);
1738
1739         if (gtk_dialog_run(GTK_DIALOG(dialog1)) == GTK_RESPONSE_OK)
1740         {
1741                 gtk_widget_destroy(GTK_WIDGET(dialog1));
1742                 gchar* tmp;
1743
1744                 ws_dbus_client_remove_bookmark(ws_gui_app->dbus_data,
1745                                         ws_gui_app->last_word);
1746
1747                 ws_gui_fill_html(" ", ws_gui_app);
1748
1749                 g_object_get(G_OBJECT(ws_gui_app->ws_gui_hildon_find_toolbar),
1750                                 "prefix",
1751                                 &tmp,
1752                                 NULL);
1753
1754                 if (strlen(tmp) != 0)
1755                 {
1756                         ws_dbus_client_find_word (ws_gui_app->dbus_data, tmp);
1757                 }
1758                 else
1759                 {
1760                         g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "strlen(tmp)=0");
1761                         gtk_list_store_clear(
1762                                        ws_gui_app->ws_gui_w_list->ws_gui_store);
1763                 }
1764         }
1765         else
1766         {
1767                 gtk_widget_destroy(GTK_WIDGET(dialog1));
1768         }
1769 }
1770
1771 void ws_gui_list_full_dialog(GtkWidget *widget, GdkEventButton *event, gpointer user_data) {
1772
1773         WSGuiApp* ws_gui_app=(WSGuiApp*)user_data;
1774
1775         ws_gui_app->ws_message_dialog =  gtk_message_dialog_new(
1776                                   GTK_WINDOW(ws_gui_app->ws_gui_hildon_window),
1777                                   GTK_DIALOG_DESTROY_WITH_PARENT,
1778                                   GTK_MESSAGE_INFO,
1779                                   GTK_BUTTONS_OK,
1780                                   _("ws_ni_words_list_full"));
1781
1782             if (gtk_dialog_run(
1783                                GTK_DIALOG(ws_gui_app->ws_message_dialog))
1784                                  == GTK_RESPONSE_OK)
1785                        {
1786                                gtk_widget_destroy(
1787                                                 ws_gui_app->ws_message_dialog);
1788                        }
1789 }