It seems that everything is working except settings (they are in TODO)

1 files changed, 218 insertions, 151 deletions

diff --git a/mainwin.c b/mainwin.c
index ffe5e6b..4cda3f0 100644
--- a/mainwin.c
+++ b/mainwin.c
@@ -10,20 +10,24 @@
  *
  * WordExtract is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with WordExtract.  If not, see <http://www.gnu.org/licenses/>.
+ * along with WordExtract. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <gdk/gdkkeysyms.h>
 #include <stdlib.h>
+#include <libgen.h>
 #include <string.h>
 #include <ctype.h>
 #include "mainwin.h"
 #include "dictwin.h"
 #include "confwin.h"
+#include "main.h"
 #include "word.h"
+#include "dict.h"
 #include "srt.h"
 
 #define SEARCH_FORWARD 0
@@ -39,6 +43,7 @@ enum {WORD_ITEM = 0, N_COLUMNS};
 GtkWidget *main_window;
 
 static GtkWidget *sentences_text;
+static GtkWidget *find_btn;
 static GtkWidget *prev_btn;
 static GtkWidget *next_btn;
 static GtkWidget *clear_btn;
@@ -51,14 +56,18 @@ static GtkWidget *save_item;
 static GtkToolItem *save;
 static GtkWidget *find_label;
 static GtkWidget *find_entry;
-/*vars to controll current word highlighting (green)*/
+/*vars to control current word highlighting (green)*/
 static int current_highlighted_end;
 static int current_highlighted_start;
+/*statusbar context id*/
+static guint id, find_id;
 
+static void set_status_msg();
 static gint main_window_close(GtkWidget *, GdkEvent *, gpointer);
 static void main_window_destroy(GtkWidget *, gpointer);
 static void open_item_click(GtkWidget *, gpointer);
-static void save_item_click(GtkWidget *, gpointer);
+static void save_words_item_click(GtkWidget *, gpointer);
+static void save_text_item_click(GtkWidget *, gpointer);
 static void quit_item_click(GtkWidget *, gpointer);
 static void dict_item_click(GtkWidget *, gpointer);
 static void pref_item_click(GtkWidget *, gpointer);
@@ -70,6 +79,7 @@ static void show_sent_item_click(GtkWidget *, gpointer );
 static void add_to_dict_item_click(GtkWidget *, gpointer );
 static void fill_list(char **);
 static void change_search_navigation_state(gboolean);
+static gboolean find_entry_key_press(GtkWidget *, GdkEventKey *, gpointer);
 static void on_find_text_change(GtkWidget *, gpointer);
 static void find_prev_btn_click(GtkWidget *, gpointer);
 static void find_next_btn_click(GtkWidget *, gpointer);
@@ -77,7 +87,7 @@ static void clear_btn_click(GtkWidget *, gpointer);
 static void search_sentences(const gchar *);
 static void set_find_text(gchar *);
 static void clear_search_tags();
-static gboolean gtk_text_iter_search_word(const GtkTextIter *, const gchar *str,
+static gboolean gtk_text_iter_search_word(const GtkTextIter *, const gchar *,
 										  GtkTextSearchFlags, GtkTextIter *,
 										  GtkTextIter *, const GtkTextIter *, int);
 static void find_other(const gchar *, const int);
@@ -91,33 +101,35 @@ void create_main_window()
  g_signal_connect(G_OBJECT(main_window), "delete_event", G_CALLBACK(main_window_close), (gpointer) main_window);
  g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_window_destroy), NULL);
 
- GtkWidget *vbox;
- vbox = gtk_vbox_new(FALSE, 2);
+ GtkWidget *vbox = gtk_vbox_new(FALSE, 2);
  gtk_widget_show(vbox);
  gtk_container_add(GTK_CONTAINER(main_window), vbox);
 
- GtkWidget *menu_bar;
- GtkWidget *view_menu;
- GtkWidget *help_menu;
- GtkWidget *sep_item;
- menu_bar = gtk_menu_bar_new();
- sep_item = gtk_separator_menu_item_new();
-
- GtkWidget *file_menu;
- GtkWidget *file_item;
- GtkWidget *open_item;
- GtkWidget *quit_item;
- file_menu = gtk_menu_new();
- file_item = gtk_menu_item_new_with_mnemonic("_File");
- open_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
- gtk_widget_set_tooltip_text(GTK_WIDGET(open_item), "Open file to analize");
+ GtkWidget *menu_bar = gtk_menu_bar_new();
+ GtkWidget *sep_item = gtk_separator_menu_item_new();
+ GtkWidget *file_menu = gtk_menu_new();
+ GtkWidget *file_item = gtk_menu_item_new_with_mnemonic("_File");
+
+ GtkWidget *open_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(open_item), "Open file to analyse");
  g_signal_connect(G_OBJECT(open_item), "activate", G_CALLBACK(open_item_click), NULL);
- save_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, NULL);
- gtk_widget_set_has_tooltip(GTK_WIDGET(save_item), FALSE);
- gtk_widget_set_tooltip_text(GTK_WIDGET(save_item), "Save list of words to file");
+ save_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE_AS, NULL);
  gtk_widget_set_sensitive(GTK_WIDGET(save_item), FALSE);
- g_signal_connect(G_OBJECT(save_item), "activate", G_CALLBACK(save_item_click), NULL);
- quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
+ GtkWidget *save_menu = gtk_menu_new();
+ GtkWidget *save_words_img = gtk_image_new_from_stock(GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU);
+ GtkWidget *save_words_item = gtk_image_menu_item_new_with_label("Words");
+ gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(save_words_item), save_words_img);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(save_words_item), "Save list of words to file");
+ g_signal_connect(G_OBJECT(save_words_item), "activate", G_CALLBACK(save_words_item_click), NULL);
+ GtkWidget *save_text_img = gtk_image_new_from_stock(GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU);
+ GtkWidget *save_text_item = gtk_image_menu_item_new_with_label("Text");
+ gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(save_text_item), save_text_img);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(save_text_item), "Save text from which words were picked up");
+ g_signal_connect(G_OBJECT(save_text_item), "activate", G_CALLBACK(save_text_item_click), NULL);
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(save_item), save_menu);
+ gtk_menu_shell_append(GTK_MENU_SHELL(save_menu), save_words_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(save_menu), save_text_item);
+ GtkWidget *quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
  gtk_widget_set_tooltip_text(GTK_WIDGET(quit_item), "Close the program");
  g_signal_connect(G_OBJECT(quit_item), "activate", G_CALLBACK(quit_item_click), NULL);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu);
@@ -128,33 +140,25 @@ void create_main_window()
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file_item);
  gtk_widget_show_all(file_item);
 
- GtkWidget *view_item;
- GtkWidget *dict_item;
- GtkWidget *edit_img;
- GtkWidget *pref_item;
- view_menu = gtk_menu_new();
- view_item = gtk_menu_item_new_with_mnemonic("_View");
- 
- dict_item = gtk_image_menu_item_new_with_label("Dictionary");
+ GtkWidget *edit_menu = gtk_menu_new();
+ GtkWidget *edit_item = gtk_menu_item_new_with_mnemonic("_Edit"); 
+ GtkWidget *dict_item = gtk_image_menu_item_new_with_label("Dictionary");
  gtk_widget_set_tooltip_text(GTK_WIDGET(dict_item), "View and edit your dictionary");
- edit_img = gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
+ GtkWidget *edit_img = gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
  gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(dict_item), edit_img);
  g_signal_connect(G_OBJECT(dict_item), "activate", G_CALLBACK(dict_item_click), NULL);
-
- pref_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
+ GtkWidget *pref_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
  gtk_widget_set_tooltip_text(GTK_WIDGET(pref_item), "Change application settings");
  g_signal_connect(G_OBJECT(pref_item), "activate", G_CALLBACK(pref_item_click), NULL);
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_item), view_menu);
- gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), dict_item);
- gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), pref_item);
- gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view_item);
- gtk_widget_show_all(view_item);
-
- GtkWidget *help_item;
- GtkWidget *about_item;
- help_menu = gtk_menu_new();
- help_item = gtk_menu_item_new_with_mnemonic("_Help");
- about_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit_item), edit_menu);
+ gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), dict_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), pref_item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), edit_item);
+ gtk_widget_show_all(edit_item);
+
+ GtkWidget *help_menu = gtk_menu_new();
+ GtkWidget *help_item = gtk_menu_item_new_with_mnemonic("_Help");
+ GtkWidget *about_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
  gtk_widget_set_tooltip_text(GTK_WIDGET(about_item), "About the program");
  g_signal_connect(G_OBJECT(about_item), "activate", G_CALLBACK(about_item_click), NULL);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(help_item), help_menu);
@@ -165,53 +169,44 @@ void create_main_window()
  gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
  gtk_widget_show(menu_bar);
 
- GtkWidget *toolbar;
- toolbar = gtk_toolbar_new();
+ GtkWidget *toolbar = gtk_toolbar_new();
  gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
- GtkToolItem *open;
- open = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
- gtk_widget_set_tooltip_text(GTK_WIDGET(open), "Open file to analize");
+ GtkToolItem *open = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(open), "Open file to analyse");
  g_signal_connect(G_OBJECT(open), "clicked", G_CALLBACK(open_item_click), NULL);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), open, -1);
  save = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE);
  gtk_widget_set_has_tooltip(GTK_WIDGET(save), FALSE);
  gtk_widget_set_tooltip_text(GTK_WIDGET(save), "Save list of words to file");
  gtk_widget_set_sensitive(GTK_WIDGET(save), FALSE);
- g_signal_connect(G_OBJECT(save), "clicked", G_CALLBACK(save_item_click), NULL);
+ g_signal_connect(G_OBJECT(save), "clicked", G_CALLBACK(save_words_item_click), NULL);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), save, -1);
- GtkToolItem *tool_sep1;
- tool_sep1 = gtk_separator_tool_item_new();
+ GtkToolItem *tool_sep1 = gtk_separator_tool_item_new();
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep1, -1); 
- GtkToolItem *dict;
- dict = gtk_tool_button_new_from_stock(GTK_STOCK_EDIT);
+ GtkToolItem *dict = gtk_tool_button_new_from_stock(GTK_STOCK_EDIT);
  gtk_widget_set_tooltip_text(GTK_WIDGET(dict), "View and edit your dictionary");
  g_signal_connect(G_OBJECT(dict), "clicked", G_CALLBACK(dict_item_click), NULL);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), dict, -1);
- GtkToolItem *tool_sep2;
- tool_sep2 = gtk_separator_tool_item_new();
+ GtkToolItem *tool_sep2 = gtk_separator_tool_item_new();
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep2, -1);  
- GtkToolItem *quit;
- quit =  gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
+ GtkToolItem *quit =  gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
  gtk_widget_set_tooltip_text(GTK_WIDGET(quit), "Close the program");
  g_signal_connect(G_OBJECT(quit), "clicked", G_CALLBACK(quit_item_click), NULL);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), quit, -1);
  gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 2); 
  gtk_widget_show_all(toolbar);
 
- GtkWidget *hpaned;
- hpaned = gtk_hpaned_new();
+ GtkWidget *hpaned = gtk_hpaned_new();
  gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
  gtk_paned_set_position(GTK_PANED(hpaned), 200);
  gtk_widget_show(hpaned);
 
- GtkWidget *word_sc_win;
- word_sc_win = gtk_scrolled_window_new(NULL, NULL);
+ GtkWidget *word_sc_win = gtk_scrolled_window_new(NULL, NULL);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(word_sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_paned_add1(GTK_PANED(hpaned), word_sc_win);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(word_sc_win), GTK_SHADOW_IN);
  gtk_widget_show(word_sc_win);
 
- GtkCellRenderer *renderer;
- GtkTreeViewColumn *column;
  word_list = gtk_tree_view_new();
  gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(word_list)), GTK_SELECTION_SINGLE);
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(word_list), FALSE);
@@ -220,36 +215,34 @@ void create_main_window()
  g_signal_connect(G_OBJECT(word_list), "popup-menu", G_CALLBACK(popup_by_keybd), NULL);
  store_model = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING);
  gtk_tree_view_set_model(GTK_TREE_VIEW(word_list), GTK_TREE_MODEL(store_model));
- renderer = gtk_cell_renderer_text_new();
+ g_object_unref(store_model);
+ GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
  g_object_set(renderer, "editable", TRUE, NULL);
- column = gtk_tree_view_column_new_with_attributes("List Items", renderer, "text", WORD_ITEM, NULL);
+ GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("List Items", renderer, "text", WORD_ITEM, NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(word_list), column);
  gtk_container_add(GTK_CONTAINER(word_sc_win), word_list);
  gtk_widget_show(word_list);
 
- GtkWidget *text_vbox;
- text_vbox = gtk_vbox_new(FALSE, 0);
+ GtkWidget *text_vbox = gtk_vbox_new(FALSE, 0);
  gtk_paned_add2(GTK_PANED(hpaned), text_vbox);
  gtk_container_set_border_width(GTK_CONTAINER(text_vbox), 2);
  gtk_widget_show(text_vbox);
 
- GtkWidget *sentences_sc_win;
- sentences_sc_win = gtk_scrolled_window_new(NULL, NULL);
+ GtkWidget *sentences_sc_win = gtk_scrolled_window_new(NULL, NULL);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sentences_sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_box_pack_start(GTK_BOX(text_vbox), sentences_sc_win, TRUE, TRUE, 0);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sentences_sc_win), GTK_SHADOW_IN);
  gtk_widget_show(sentences_sc_win);
 
- GtkTextBuffer *buffer;
  sentences_text = gtk_text_view_new();
- buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
  gtk_text_view_set_editable(GTK_TEXT_VIEW(sentences_text), FALSE);
  gtk_text_buffer_create_tag(buffer, "yellow-bg", "background", "yellow", NULL);
  gtk_text_buffer_create_tag(buffer, "green-bg", "background", "green", NULL);
  gtk_container_add(GTK_CONTAINER(sentences_sc_win), sentences_text);
  gtk_widget_show(sentences_text);
 
- GtkWidget *text_hbox;
- text_hbox = gtk_hbox_new(FALSE, 0);
+ GtkWidget *text_hbox = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_end(GTK_BOX(text_vbox), text_hbox, FALSE, FALSE, 0);
  gtk_widget_show(text_hbox);
 
@@ -262,9 +255,18 @@ void create_main_window()
  gtk_box_pack_start(GTK_BOX(text_hbox), find_entry, FALSE, FALSE, 0);
  gtk_widget_set_sensitive(GTK_WIDGET(find_entry), FALSE);
  g_signal_connect(G_OBJECT(find_entry), "activate", G_CALLBACK(on_find_text_change), NULL);
+ g_signal_connect(G_OBJECT(find_entry), "key-press-event", G_CALLBACK(find_entry_key_press), NULL);
  gtk_widget_show(find_entry);
 
- GtkWidget *image;
+ find_btn = gtk_button_new();
+ GtkWidget *image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON);
+ gtk_container_add(GTK_CONTAINER(find_btn), image);
+ gtk_widget_show(image);
+ gtk_box_pack_start(GTK_BOX(text_hbox), find_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(find_btn), "Find word");
+ gtk_widget_set_sensitive(GTK_WIDGET(find_btn), FALSE);
+ g_signal_connect(G_OBJECT(find_btn), "clicked", G_CALLBACK(on_find_text_change), NULL);
+ gtk_widget_show(find_btn);
 
  prev_btn = gtk_button_new();
  image = gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON);
@@ -298,15 +300,24 @@ void create_main_window()
 
  statusbar = gtk_statusbar_new();
  gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
+ id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "main_context");
+ find_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "find_context");
+ gtk_statusbar_push(GTK_STATUSBAR(statusbar), id, "Open file to pick up words from it...");
  gtk_widget_show(statusbar);
 }
 
+static void set_status_msg()
+{
+ char words_cnt_str[40] = {0};
+ sprintf(words_cnt_str, "<b> Words in your dictionary: %d</b>", dict_words.count);
+ gtk_statusbar_pop(GTK_STATUSBAR(statusbar), find_id);
+}
+
 static gint main_window_close(GtkWidget *widget, GdkEvent *event, gpointer main_window)
 {
- GtkWidget *dialog;
  gint response = TRUE;
 
- dialog = gtk_message_dialog_new(main_window, GTK_DIALOG_DESTROY_WITH_PARENT,
+ GtkWidget *dialog = gtk_message_dialog_new(main_window, GTK_DIALOG_DESTROY_WITH_PARENT,
 								 GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, QUIT_MSG_TEXT); 
  gtk_window_set_title(GTK_WINDOW(dialog), QUIT_MSG_CAPTION);
  if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES)
@@ -323,21 +334,17 @@ static void main_window_destroy(GtkWidget *widget, gpointer data)
 
 static void open_item_click(GtkWidget *widget, gpointer data)
 {
- GtkWidget *filedialog;
- GtkWidget *errmsg;
- GtkFileFilter *filter;
  char *filename;
  char *errstr;
  FILE *subtitle;
- char **word_list;
 
- filter = gtk_file_filter_new();
+ GtkFileFilter *filter = gtk_file_filter_new();
  gtk_file_filter_add_mime_type(filter, "application/x-subrip");
  gtk_file_filter_set_name(filter, "SubRip subtitles (*srt)");
- filedialog = gtk_file_chooser_dialog_new("Open File for analizing", GTK_WINDOW(main_window),
-										GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, 
-										GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
-										GTK_RESPONSE_ACCEPT, NULL);
+ GtkWidget *filedialog = gtk_file_chooser_dialog_new("Open File for analysing", 
+							GTK_WINDOW(main_window), GTK_FILE_CHOOSER_ACTION_OPEN,
+							GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
+							GTK_RESPONSE_ACCEPT, NULL);
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filedialog), filter);
  if (gtk_dialog_run(GTK_DIALOG(filedialog)) == GTK_RESPONSE_ACCEPT) {
 	filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filedialog));
@@ -346,7 +353,7 @@ static void open_item_click(GtkWidget *widget, gpointer data)
 		errstr = malloc(strlen(filename) + strlen(ERR_READING_FILE));
 		strcpy(errstr, ERR_READING_FILE);
 		strcat(errstr, filename);
-		errmsg = gtk_message_dialog_new(GTK_WINDOW(main_window), 
+		GtkWidget *errmsg = gtk_message_dialog_new(GTK_WINDOW(main_window),
 										GTK_DIALOG_DESTROY_WITH_PARENT,
 										GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, errstr);
 		gtk_window_set_title(GTK_WINDOW(errmsg), ERR_MSG_CAPTION);
@@ -356,39 +363,41 @@ static void open_item_click(GtkWidget *widget, gpointer data)
 		return ;
 	 }
 	if (words != NULL) {
-		/*we won't free() 'words' variable, it's statical*/
-		free_words(words->lsibl);
-		free_words(words->rsibl);
-		free(words->word);
+		free(user_words.by_az);
+		free_words(words);
 		words = NULL;
 		gtk_list_store_clear(store_model);
 		clear_sentences();
 	} else {
 		gtk_widget_set_sensitive(GTK_WIDGET(find_label), TRUE);
 		gtk_widget_set_sensitive(GTK_WIDGET(find_entry), TRUE);
+		gtk_widget_set_sensitive(GTK_WIDGET(find_btn), TRUE);
 		gtk_widget_set_sensitive(GTK_WIDGET(save_item), TRUE);
 		gtk_widget_set_sensitive(GTK_WIDGET(save), TRUE);
 	}
 	process_srt(subtitle);
-	word_list = get_sorted(words);
-	fill_list(word_list);
-	free(word_list);
+	user_words = get_sorted(words);
+	fill_list(user_words.by_az);
 	fclose(subtitle);
+	gchar *file = malloc(strlen(filename)+1);
+	file = basename(filename);
+	gchar *status_msg = malloc(strlen(file)+40);
+	sprintf(status_msg, "%d words were picked up from '%s'", user_words.count, file);
+	gtk_statusbar_pop(GTK_STATUSBAR(statusbar), id);
+	gtk_statusbar_push(GTK_STATUSBAR(statusbar), id, status_msg);
  }
  gtk_widget_destroy(filedialog);
 }
 
-static void save_item_click(GtkWidget *widget, gpointer data)
+static void save_words_item_click(GtkWidget *widget, gpointer data)
 {
- GtkWidget *filedialog;
- GtkWidget *errmsg;
  FILE *savefile;
- char *filename;
- char *errstr;
+ gchar *filename;
+ gchar *errstr;
 
- filedialog = gtk_file_chooser_dialog_new("Save list of words as...", GTK_WINDOW(main_window), 
-									GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL,
-									GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, 
+ GtkWidget *filedialog = gtk_file_chooser_dialog_new("Save list of words as...",
+									GTK_WINDOW(main_window), GTK_FILE_CHOOSER_ACTION_SAVE,
+									GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, 
 									GTK_RESPONSE_ACCEPT, NULL);
  if (gtk_dialog_run(GTK_DIALOG(filedialog)) == GTK_RESPONSE_ACCEPT) {
 	filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filedialog));
@@ -397,7 +406,7 @@ static void save_item_click(GtkWidget *widget, gpointer data)
 		errstr = malloc(strlen(filename) + strlen(ERR_SAVING_FILE));
 		strcpy(errstr, ERR_SAVING_FILE);
 		strcat(errstr, filename);
-		errmsg = gtk_message_dialog_new(GTK_WINDOW(main_window), 
+		GtkWidget *errmsg = gtk_message_dialog_new(GTK_WINDOW(main_window), 
 										GTK_DIALOG_DESTROY_WITH_PARENT,
 										GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, errstr);
 		gtk_window_set_title(GTK_WINDOW(errmsg), ERR_MSG_CAPTION);
@@ -406,15 +415,52 @@ static void save_item_click(GtkWidget *widget, gpointer data)
 		free(errstr);
 		return ;
 	}
+	save_words(savefile, user_words, save_user_words);
+	fclose(savefile);
  }
  gtk_widget_destroy(filedialog);
 }
 
-static void quit_item_click(GtkWidget *widget, gpointer data)
+static void save_text_item_click(GtkWidget *widget, gpointer data)
 {
- GtkWidget *dialog;
+ FILE *savefile;
+ gchar *filename;
+ gchar *errstr;
+ gchar *text;
 
- dialog = gtk_message_dialog_new(GTK_WINDOW(main_window), GTK_DIALOG_DESTROY_WITH_PARENT,
+ GtkWidget *filedialog = gtk_file_chooser_dialog_new("Save text as...",
+									GTK_WINDOW(main_window), GTK_FILE_CHOOSER_ACTION_SAVE,
+									GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, 
+									GTK_RESPONSE_ACCEPT, NULL);
+ if (gtk_dialog_run(GTK_DIALOG(filedialog)) == GTK_RESPONSE_ACCEPT) {
+	filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filedialog));
+	if (!(savefile = fopen(filename, "w"))) {
+		gtk_widget_destroy(filedialog);
+		errstr = malloc(strlen(filename) + strlen(ERR_SAVING_FILE));
+		strcpy(errstr, ERR_SAVING_FILE);
+		strcat(errstr, filename);
+		GtkWidget *errmsg = gtk_message_dialog_new(GTK_WINDOW(main_window), 
+										GTK_DIALOG_DESTROY_WITH_PARENT,
+										GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, errstr);
+		gtk_window_set_title(GTK_WINDOW(errmsg), ERR_MSG_CAPTION);
+		gtk_dialog_run(GTK_DIALOG(errmsg));
+		gtk_widget_destroy(errmsg);
+		return ;
+	}
+	GtkTextIter start, end;
+	GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
+	gtk_text_buffer_get_start_iter(buffer, &start);
+	gtk_text_buffer_get_end_iter(buffer, &end);
+	text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
+	fprintf(savefile, text);
+	fclose(savefile);
+ }
+ gtk_widget_destroy(filedialog);
+}
+
+static void quit_item_click(GtkWidget *widget, gpointer data)
+{
+ GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(main_window), GTK_DIALOG_DESTROY_WITH_PARENT,
 								 GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, QUIT_MSG_TEXT); 
  gtk_window_set_title(GTK_WINDOW(dialog), QUIT_MSG_CAPTION);
  if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES) {
@@ -439,16 +485,21 @@ static void about_item_click(GtkWidget *widget, gpointer data)
 {
  const gchar comment[] = {"WordExtract is a subtitle parser\n which shows all unique words\n from files."}; 
  const gchar copyright[] = {"Copyright \xc2\xa9 2009 by Borisov Alexandr"};
- const gchar gplv3[] = {"This program is free software: you can redistribute it and/or modify\n"
-						  "it under the terms of the GNU General Public License as published by\n"
-						  "the Free Software Foundation, either version 3 of the License, or\n"
-						  "(at your option) any later version.\n\n"
-						  "This program is distributed in the hope that it will be useful,\n"
-						  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
-						  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
-						  "GNU General Public License for more details.\n\n"
-						  "You should have received a copy of the GNU General Public License\n"
-						  "along with this program.  If not, see <http://www.gnu.org/licenses/>."};
+ const gchar gplv3[] = {"WordExtract is free software: you can\n"
+						"redistribute it and/or modify it under the\n"
+						"terms of the GNU General Public License as\n"
+						"published by the Free Software Foundation,\n"
+						"either version 3 of the License, or (at your\n"
+						"option) any later version.\n\n"
+						"WordExtract is distributed in the hope that\n"
+						"it will be useful, but WITHOUT ANY WARRANTY;\n"
+						"without even the implied warranty of\n"
+						"MERCHANTABILITY or FITNESS FOR A PARTICULAR\n"
+						"PURPOSE. See the GNU General Public License\n"
+						"for more details.\n\n"
+						"You should have received a copy of the GNU\n"
+						"General Public License along with WordExtract.\n"
+						"If not, see <http://www.gnu.org/licenses/>."};
  const gchar *authors[] = {"Borisov Alexandr aka b0ric", NULL};
 
  gtk_show_about_dialog(GTK_WINDOW(main_window),	"name", "WordExtract",
@@ -465,11 +516,10 @@ static void about_item_click(GtkWidget *widget, gpointer data)
 
 static gboolean popup_by_click(GtkWidget *word_list, GdkEventButton *event, gpointer data)
 {
- GtkTreeSelection *selection;
  GtkTreePath *path;
 
  if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
-	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(word_list));
+	GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(word_list));
 	if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(selection), NULL, NULL)) {
 		if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(word_list), (gint) event->x, 
 										  (gint) event->y, &path, NULL, NULL, NULL)) {
@@ -491,26 +541,21 @@ static gboolean popup_by_keybd(GtkWidget *word_list, gpointer data)
 
 static void word_list_popup(GtkWidget *widget, GdkEventButton *event)
 {
- GtkWidget *popup_menu;
- popup_menu = gtk_menu_new();
- GtkWidget *show_sent_item;
- show_sent_item = gtk_image_menu_item_new_with_label("Show Sentence");
+ GtkWidget *popup_menu = gtk_menu_new();
+ GtkWidget *show_sent_item = gtk_image_menu_item_new_with_label("Show Sentence");
  gtk_menu_shell_append(GTK_MENU_SHELL(popup_menu), show_sent_item);
  gtk_widget_show(show_sent_item);
  g_signal_connect(G_OBJECT(show_sent_item), "activate", G_CALLBACK(show_sent_item_click), NULL);
  gtk_widget_set_tooltip_text(GTK_WIDGET(show_sent_item), "Show sentenses word appears in");
- GtkWidget *find_image;
- find_image = gtk_image_new_from_stock("gtk-find", GTK_ICON_SIZE_MENU);
+ GtkWidget *find_image = gtk_image_new_from_stock("gtk-find", GTK_ICON_SIZE_MENU);
  gtk_widget_show(find_image);
  gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(show_sent_item), find_image);
- GtkWidget *add_to_dict_item;
- add_to_dict_item = gtk_image_menu_item_new_with_label("Add To Dictionary");
+ GtkWidget *add_to_dict_item = gtk_image_menu_item_new_with_label("Add To Dictionary");
  gtk_widget_show(add_to_dict_item);
  gtk_menu_shell_append(GTK_MENU_SHELL(popup_menu), add_to_dict_item);
  g_signal_connect(add_to_dict_item, "activate", G_CALLBACK(add_to_dict_item_click), NULL);
  gtk_widget_set_tooltip_text(GTK_WIDGET(add_to_dict_item), "Add word to my dictionary");
- GtkWidget *add_image;
- add_image = gtk_image_new_from_stock("gtk-add", GTK_ICON_SIZE_MENU);
+ GtkWidget *add_image = gtk_image_new_from_stock("gtk-add", GTK_ICON_SIZE_MENU);
  gtk_widget_show(add_image);
  gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(add_to_dict_item), add_image);
  gtk_widget_show(popup_menu);
@@ -520,12 +565,11 @@ static void word_list_popup(GtkWidget *widget, GdkEventButton *event)
 
 static void show_sent_item_click(GtkWidget *widget, gpointer data)
 {
- GtkTreeSelection *selection;
  GtkTreeModel *model;
  GtkTreeIter iter;
  gchar *word;
 
- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(word_list));
+ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(word_list));
  if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
 	gtk_tree_model_get(model, &iter, 0, &word, -1);
 	set_find_text(word);
@@ -537,7 +581,16 @@ static void show_sent_item_click(GtkWidget *widget, gpointer data)
 
 static void add_to_dict_item_click(GtkWidget *widget, gpointer data)
 {
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gchar *word;
 
+ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(word_list));
+ if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
+	gtk_tree_model_get(model, &iter, 0, &word, -1);
+	add_word(dict, word);
+	g_free(word);
+ }
 }
 
 static void fill_list(char **word_list)
@@ -562,15 +615,22 @@ static void change_search_navigation_state(gboolean state)
 
 void add_sentence(char *sentence)
 {
- GtkTextBuffer *buffer;
  GtkTextIter iter;
 
- buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
  gtk_text_buffer_get_end_iter(buffer, &iter);
  gtk_text_buffer_insert(buffer, &iter, (gchar*) sentence, -1);
 }
 
-static void on_find_text_change(GtkWidget *widget, gpointer datd)
+static gboolean find_entry_key_press(GtkWidget *entry, GdkEventKey *event, gpointer data)
+{
+ if (event->type == GDK_KEY_PRESS)
+	if ((event->length)||(event->keyval == GDK_BackSpace)||(event->keyval == GDK_Delete))
+		set_status_msg();
+ return FALSE;
+}
+
+static void on_find_text_change(GtkWidget *widget, gpointer data)
 {
  const gchar *find_text;
 
@@ -600,6 +660,7 @@ static void clear_btn_click(GtkWidget *widget, gpointer data)
 {
  clear_search_tags();
  gtk_entry_set_text(GTK_ENTRY(find_entry), "");
+ set_status_msg();
  change_search_navigation_state(FALSE);
 }
 
@@ -614,12 +675,11 @@ void clear_sentences()
 
 static void search_sentences(const gchar *word)
 {
- GtkTextBuffer *buffer;
  GtkTextIter find_start, find_end;
  GtkTextIter match_start, match_end;
- int offset;
+ int offset, cnt = 0;
 
- buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
  gtk_text_buffer_get_start_iter(buffer, &find_start);
  gtk_text_buffer_get_end_iter(buffer, &find_end);
  gtk_text_buffer_remove_tag_by_name(buffer, "green-bg", &find_start, &find_end); 
@@ -630,7 +690,16 @@ static void search_sentences(const gchar *word)
 	gtk_text_buffer_apply_tag_by_name(buffer, "yellow-bg", &match_start, &match_end);
 	offset = gtk_text_iter_get_offset(&match_end);
  	gtk_text_buffer_get_iter_at_offset(buffer, &find_start, offset);
+	cnt++;
+ }
+
+ if (!cnt) {
+	char status_msg[50] = {0};
+	sprintf(status_msg, "Word '%s' was not found", word);
+	gtk_statusbar_pop(GTK_STATUSBAR(statusbar), find_id);
+	gtk_statusbar_push(GTK_STATUSBAR(statusbar), find_id, (gchar *) status_msg);
  }
+
  gtk_text_buffer_get_start_iter(buffer, &find_start);
  gtk_text_buffer_get_end_iter(buffer, &find_end);
  if (gtk_text_iter_search_word(&find_start, word, GTK_TEXT_SEARCH_TEXT_ONLY| 
@@ -650,14 +719,13 @@ static void set_find_text(gchar *text)
 
 static void clear_search_tags()
 {
- GtkTextBuffer *buffer;
- GtkTextIter find_start, find_end;
+ GtkTextIter start, end;
 
- buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
- gtk_text_buffer_get_start_iter(buffer, &find_start);
- gtk_text_buffer_get_end_iter(buffer, &find_end);
- gtk_text_buffer_remove_tag_by_name(buffer, "yellow-bg", &find_start, &find_end);
- gtk_text_buffer_remove_tag_by_name(buffer, "green-bg", &find_start, &find_end);
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
+ gtk_text_buffer_get_start_iter(buffer, &start);
+ gtk_text_buffer_get_end_iter(buffer, &end);
+ gtk_text_buffer_remove_tag_by_name(buffer, "yellow-bg", &start, &end);
+ gtk_text_buffer_remove_tag_by_name(buffer, "green-bg", &start, &end);
 }
 
 /* We won't need this abomination if GTK developers implement 
@@ -676,7 +744,7 @@ static gboolean gtk_text_iter_search_word(const GtkTextIter *iter, const gchar *
 
  str_wcap = malloc((strlen(str)+1)*sizeof(gchar));
  strcpy(str_wcap, str);
- /* We've lowered only first letter, so there are only two variants*/
+ /* We've lowered only first letter, so there are only two cases*/
  *str_wcap = toupper(*str_wcap);
  if (direction == SEARCH_FORWARD) {
 	if (gtk_text_iter_forward_search(iter, str, flags, match_start, match_end, limit))
@@ -713,11 +781,10 @@ static gboolean gtk_text_iter_search_word(const GtkTextIter *iter, const gchar *
 
 static void find_other(const gchar *word, const int direction)
 {
- GtkTextBuffer *buffer;
  GtkTextIter find_start, find_end;
  GtkTextIter match_start, match_end;
 
- buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
  gtk_text_buffer_get_start_iter(buffer, &find_start);
  gtk_text_buffer_get_end_iter(buffer, &find_end);
  gtk_text_buffer_remove_tag_by_name(buffer, "green-bg", &find_start, &find_end);