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

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