projects / mdictionary / blob
? search:


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