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