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