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

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