Basical GUI functionality and few GIU improvements

12 files changed, 647 insertions, 148 deletions

diff --git a/Makefile b/Makefile
index 530312f..6c0b512 100644
--- a/Makefile
+++ b/Makefile
@@ -2,15 +2,18 @@ CC=gcc
 CFLAGS=-Wall -g `pkg-config --cflags gtk+-2.0`
 LDLIBS=`pkg-config --libs gtk+-2.0`
 
-wordextract: main.o interface.o callbacks.o dict.o srt.o engparser.o word.o
-	$(CC) $(LDLIBS) main.o interface.o callbacks.o dict.o srt.o engparser.o word.o -o wordextract
+wordextract: main.o interface.o listview.o callbacks.o dict.o srt.o engparser.o word.o
+	$(CC) $(LDLIBS) main.o interface.o listview.o callbacks.o dict.o srt.o engparser.o word.o -o wordextract
 
 main.o: main.c interface.h dict.h srt.h subtitle.h
 	$(CC) $(CFLAGS) -c main.c
 
-interface.o: interface.c interface.h callbacks.h
+interface.o: interface.c interface.h listview.h
 	$(CC) $(CFLAGS) -c interface.c
 
+listview.o: listview.c listview.h
+	$(CC) $(CFLAGS) -c listview.c
+
 callbacks.o: callbacks.c callbacks.h
 	$(CC) $(CFLAGS) -c callbacks.c
 
@@ -23,7 +26,7 @@ srt.o: srt.c srt.h subtitle.h engparser.h
 enrparser.o: engparser.c engparser.h word.h
 	$(CC) $(CFLAGS) -c engparser.c
 
-word.o: word.c word.h
+word.o: word.c word.h interface.h
 	$(CC) $(CFLAGS) -c word.c
 
 install: wordextract
diff --git a/callbacks.c b/callbacks.c
index 3cbb345..a2f94f8 100644
--- a/callbacks.c
+++ b/callbacks.c
@@ -17,15 +17,154 @@
  */
 
 #include <gtk/gtk.h>
+#include <stdlib.h>
+#include <string.h>
 #include "callbacks.h"
+#include "subtitle.h"
+#include "interface.h"
+#include "srt.h"
+#include "word.h"
 
-gint main_window_close(GtkWidget *widget, GdkEvent *event, gpointer data)
+#define QUIT_MSG_CAPTION "Confirmation"
+#define QUIT_MSG_TEXT "Are you sure to exit?"
+#define ERR_READING_FILE "Error reading file"
+#define ERR_MSG_CAPTION "Error"
+
+extern Word *words;
+
+gint main_window_close(GtkWidget *widget, GdkEvent *event, gpointer main_window)
 {
+ GtkWidget *dialog;
+ gint response = TRUE;
 
-return FALSE;
+ 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)
+	response = FALSE;
+ gtk_widget_destroy(dialog);
+
+ return response;
 }
 
 void main_window_destroy(GtkWidget *widget, gpointer data)
 {
  gtk_main_quit();
 }
+
+void open_btn_click(GtkWidget *widget, gpointer parent)
+{
+ GtkWidget *filedialog;
+ GtkWidget *errmsg;
+ GtkFileFilter *filter;
+ char *filename;
+ char *errstr;
+ FILE *subtitle;
+
+ 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", parent, 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));
+	if (!(subtitle = fopen(filename, "r"))) {
+		gtk_widget_destroy(filedialog);
+		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), 
+										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);
+		free(errstr);
+		return ;
+	 }
+	if (words != NULL) {
+		/*we won't free() 'words' variable, it's statical*/
+		free_words(words->lsibl);
+		free_words(words->rsibl);
+		free(words->word);
+		words = NULL;
+		clear_word_list();
+		clear_sentences();
+	} 
+	else
+		enable_search();
+	process_srt(subtitle);
+	print_words(words);
+	fclose(subtitle);
+ }
+ gtk_widget_destroy(filedialog);
+}
+
+void show_about(GtkWidget *widget, gpointer data)
+{
+ const gchar *authors[] = {"Borisov Alexandr aka b0ric", NULL};
+ 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"};
+
+ gtk_show_about_dialog(GTK_WINDOW(main_window),	"name", "WordExtract",
+			      								"version", "v0.2",
+											    "website", "http://null.net",
+											    "comments", comment,
+			  								    "copyright", copyright,
+			      								"authors", authors,
+											    "documenters", NULL,
+			     								"translator-credits", NULL,
+			      								"logo", NULL, NULL);
+}
+
+void quit_btn_click(GtkWidget *widget, gpointer data)
+{
+ GtkWidget *dialog;
+
+ 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) {
+	gtk_widget_destroy(dialog);	
+	gtk_main_quit();
+ }
+ else
+	gtk_widget_destroy(dialog);
+}
+
+void on_find_text_change(GtkWidget *find_entry, gpointer data)
+{
+ const gchar *find_text;
+
+ find_text = gtk_entry_get_text(GTK_ENTRY(find_entry));
+ change_search_navigation_state(strcmp(find_text, ""));
+ if (strcmp(find_text, "")) 
+	search_sentences(find_text);
+}
+
+void find_next_btn_click(GtkWidget *widget, gpointer entry)
+{
+ const gchar *find_text = NULL;
+
+ find_text = gtk_entry_get_text(GTK_ENTRY(entry));
+ find_next(find_text);
+}
+
+void find_prev_btn_click(GtkWidget *widget, gpointer entry)
+{
+ const gchar *find_text = NULL;
+
+ find_text = gtk_entry_get_text(GTK_ENTRY(entry));
+ find_prev(find_text);
+}
+
+void clear_btn_click(GtkWidget *widget, gpointer find_entry)
+{
+ clear_search_tags();
+ gtk_entry_set_text(GTK_ENTRY(find_entry), "");
+ change_search_navigation_state(FALSE);
+}
+
+
diff --git a/callbacks.h b/callbacks.h
index a41b715..03c90a4 100644
--- a/callbacks.h
+++ b/callbacks.h
@@ -19,7 +19,14 @@
 #ifndef CALLBACKS_H
 #define CALLBACKS_H
 
-gint main_window_close(GtkWidget *widget, GdkEvent *event, gpointer data);
-void main_window_destroy(GtkWidget *widget, gpointer data);
+gint main_window_close(GtkWidget *, GdkEvent *, gpointer);
+void main_window_destroy(GtkWidget *, gpointer);
+void open_btn_click(GtkWidget *, gpointer);
+void show_about(GtkWidget *widget, gpointer data);
+void quit_btn_click(GtkWidget *, gpointer);
+void on_find_text_change(GtkWidget *, gpointer);
+void find_prev_btn_click(GtkWidget *widget, gpointer entry);
+void find_next_btn_click(GtkWidget *widget, gpointer entry);
+void clear_btn_click(GtkWidget *, gpointer);
 
 #endif /*CALLBACKS_H*/
diff --git a/dict.h b/dict.h
index 506c045..500e7eb 100644
--- a/dict.h
+++ b/dict.h
@@ -16,8 +16,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef DICT_H
-#define DICT_H
+#ifndef DICTIONARY_H
+#define DICTIONARY_H
 
 #include "word.h"
 
@@ -28,6 +28,6 @@
 Word *dict;
 
 Word *load_dict(FILE *);
-int is_in_dict(char *word, Word *dic_rec);
+int is_in_dict(char *, Word *);
 
 #endif /*DICT_H*/
diff --git a/engparser.c b/engparser.c
index 2c3c77f..e5b17e6 100644
--- a/engparser.c
+++ b/engparser.c
@@ -19,6 +19,7 @@
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
+#include "interface.h"
 #include "engparser.h"
 #include "word.h"
 
@@ -29,6 +30,8 @@ int excl_w_capital = 1;
 Parseoptions hyphen = {'-', 0, 1, 0, 1, 0};
 Parseoptions quote = {'\'', 0, 1, 1, 0, 0};
 
+
+/* It deletes first and last symbol in the word*/
 static void del_first_n_last(char *word);
 
 /*
@@ -48,6 +51,7 @@ int parseengphrase(char *phrase)
  int sentence_start = 1;
  int i, k;
 
+ add_sentence(phrase);
  for (i = 0, k = 0; phrase[k] != '\0'; k++) {
 	 if ((isalpha(phrase[k]))||(phrase[k] == '\'')||(phrase[k] == '-'))
 		{
@@ -110,9 +114,6 @@ int parse_eng_word(char *word, Parseoptions opt)
  return WORD_INCLUDED;
 }
 
-/*
- * It deletes first and last symbol in the word
- */
 static void del_first_n_last(char *word)
 {
  int i, k;
diff --git a/interface.c b/interface.c
index d494a1c..e44ed96 100644
--- a/interface.c
+++ b/interface.c
@@ -16,144 +16,172 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <gtk/gtk.h>
 #include "interface.h"
 #include "callbacks.h"
+#include "word.h"
 
 static GtkWidget *gtk_button_new_with_label_and_image(gchar *img_file, gchar *label);
 
-GtkWidget *create_main_window()
+static GtkWidget *sentences_text;
+static GtkWidget *find_label;
+static GtkWidget *find_entry;
+static GtkWidget *prev_btn;
+static GtkWidget *next_btn;
+static GtkWidget *clear_btn;
+static GtkWidget *statusbar;
+static int current_highlighted_end;
+static int current_highlighted_start;
+
+void create_main_window()
 {
- GtkWidget *main_window;
- GtkWidget *vbox;
- GtkWidget *tool_hbox;
- GtkWidget *open_btn;
- GtkWidget *save_btn;
- GtkWidget *preferences_btn;
- GtkWidget *dict_btn;
- GtkWidget *about_btn;
- GtkWidget *quit_btn;
- GtkWidget *hpaned;
- GtkWidget *word_sc_win;
- GtkWidget *word_list;
- GtkWidget *sentences_sc_win;
- GtkWidget *sentences_text;
- GtkWidget *statusbar;
-
  main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_widget_set_size_request(main_window, 640, 480);
  gtk_container_set_border_width(GTK_CONTAINER(main_window), 2);
  gtk_window_set_title(GTK_WINDOW(main_window), "WordExtract");
  gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER);
- g_signal_connect(G_OBJECT(main_window), "delete_event", G_CALLBACK(main_window_close), NULL);
+ 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, 0);
  gtk_widget_show(vbox);
  gtk_container_add(GTK_CONTAINER(main_window), vbox);
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);
 
+ GtkWidget *tool_hbox;
  tool_hbox = gtk_hbox_new(FALSE, 0);
- gtk_widget_show(tool_hbox);
  gtk_box_pack_start(GTK_BOX(vbox), tool_hbox, FALSE, FALSE, 0);
+ gtk_widget_show(tool_hbox);
 
- open_btn = gtk_button_new_with_label_and_image("gtk-open", "Open");
- gtk_widget_show(open_btn);
+ GtkWidget *open_btn;
+ open_btn = gtk_button_new_from_stock(GTK_STOCK_OPEN);
  gtk_box_pack_start(GTK_BOX(tool_hbox), open_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(open_btn), "Open file to pick up words");
+ gtk_widget_show(open_btn);
+ g_signal_connect(G_OBJECT(open_btn), "clicked", G_CALLBACK(open_btn_click), NULL);
 
- save_btn = gtk_button_new_with_label_and_image("gtk-save-as", "Save");
- gtk_widget_show(save_btn);
+ GtkWidget *save_btn;
+ save_btn = gtk_button_new_from_stock(GTK_STOCK_SAVE_AS);
  gtk_box_pack_start(GTK_BOX(tool_hbox), save_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(save_btn), "Save list of words to file");
+ gtk_widget_show(save_btn);
 
- preferences_btn = gtk_button_new_with_label_and_image("gtk-preferences", "Preferences");
- gtk_widget_show (preferences_btn);
+ GtkWidget *preferences_btn;
+ preferences_btn = gtk_button_new_from_stock(GTK_STOCK_PREFERENCES);
  gtk_box_pack_start (GTK_BOX (tool_hbox), preferences_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(preferences_btn), "Application and analizing options");
+ gtk_widget_show (preferences_btn);
 
+ GtkWidget *dict_btn;
  dict_btn = gtk_button_new_with_label_and_image("gtk-edit", "Dictionary");
- gtk_widget_show(dict_btn);
  gtk_box_pack_start(GTK_BOX(tool_hbox), dict_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(dict_btn), "View words in dictionary");
+ gtk_widget_show(dict_btn);
 
- quit_btn = gtk_button_new_with_label_and_image("gtk-quit", "Quit");
- gtk_widget_show (quit_btn);
+ GtkWidget *quit_btn;
+ quit_btn = gtk_button_new_from_stock(GTK_STOCK_QUIT);
  gtk_box_pack_end(GTK_BOX(tool_hbox), quit_btn, FALSE, FALSE, 0);
+ gtk_widget_show (quit_btn);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(quit_btn), "Close this application");
+ g_signal_connect(G_OBJECT(quit_btn), "clicked", G_CALLBACK(quit_btn_click), (gpointer) main_window);
 
- about_btn = gtk_button_new_with_label_and_image("gtk-about", "About");
- gtk_widget_show(about_btn);
+ GtkWidget *about_btn;
+ about_btn = gtk_button_new_from_stock(GTK_STOCK_ABOUT);
  gtk_box_pack_end(GTK_BOX(tool_hbox), about_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(about_btn), "About this application");
+ gtk_widget_show(about_btn);
+ g_signal_connect(G_OBJECT(about_btn), "clicked", G_CALLBACK(show_about), NULL);
 
+ GtkWidget *hpaned;
  hpaned = gtk_hpaned_new();
- gtk_widget_show(hpaned);
  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);
- gtk_widget_show(word_sc_win);
  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);
+
+ GtkWidget *list;
+ list = create_word_list();
+ gtk_container_add(GTK_CONTAINER(word_sc_win), list);
+ gtk_widget_show(list);
 
- word_list = gtk_tree_view_new();
- gtk_widget_show(word_list);
- gtk_container_add(GTK_CONTAINER(word_sc_win), word_list);
- gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(word_list), FALSE);
- gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(word_list), TRUE);
+ GtkWidget *text_vbox;
+ 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);
 
- sentences_sc_win = gtk_scrolled_window_new (NULL, NULL);
- gtk_widget_show (sentences_sc_win);
- gtk_paned_add2(GTK_PANED(hpaned), sentences_sc_win);
- gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sentences_sc_win), GTK_SHADOW_IN);
+ GtkWidget *sentences_sc_win;
+ sentences_sc_win = gtk_scrolled_window_new(NULL, NULL);
+ 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();
- gtk_widget_show(sentences_text);
- gtk_container_add(GTK_CONTAINER(sentences_sc_win), sentences_text);
+ 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);
 
- statusbar = gtk_statusbar_new();
- gtk_widget_show(statusbar);
- gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
-
- return main_window;
-}
-
-/*GtkWidget *create_popup_menu(void)
-{
-  GtkWidget *popup_menu;
-  GtkWidget *show_sent_item;
-  GtkWidget *find_image;
-  GtkWidget *add_to_dict_item;
-  GtkWidget *add_image;
-  GtkTooltips *tooltips;
-
-  tooltips = gtk_tooltips_new ();
-
-  popup_menu = gtk_menu_new ();
-
-  show_sent_item = gtk_image_menu_item_new_with_mnemonic (_("Show Sentence"));
-  gtk_widget_show (show_sent_item);
-  gtk_container_add (GTK_CONTAINER (popup_menu), show_sent_item);
-  gtk_tooltips_set_tip (tooltips, show_sent_item, _("Show sentenses word appears in"), NULL);
+ GtkWidget *text_hbox;
+ 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);
 
-  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);
+ find_label = gtk_label_new("Find: ");
+ gtk_box_pack_start(GTK_BOX(text_hbox), find_label, FALSE, FALSE, 0);
+ gtk_widget_set_sensitive(GTK_WIDGET(find_label), FALSE);
+ gtk_widget_show(find_label);
 
-  add_to_dict_item = gtk_image_menu_item_new_with_mnemonic (_("Add To Dictionary"));
-  gtk_widget_show (add_to_dict_item);
-  gtk_container_add (GTK_CONTAINER (popup_menu), add_to_dict_item);
-  gtk_tooltips_set_tip (tooltips, add_to_dict_item, _("Add word to my dictionary"), NULL);
+ find_entry = gtk_entry_new_with_max_length(WORDLENGTH);
+ 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);
+ gtk_widget_show(find_entry);
 
-  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);
+ GtkWidget *image;
 
-  g_signal_connect ((gpointer) show_sent_item, "activate",
-                    G_CALLBACK (on_show_sent_item_activate),
-                    NULL);
-  g_signal_connect ((gpointer) add_to_dict_item, "activate",
-                    G_CALLBACK (on_add_to_dict_item_activate),
-                    NULL);
+ prev_btn = gtk_button_new();
+ image = gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON);
+ gtk_container_add(GTK_CONTAINER(prev_btn), image);
+ gtk_widget_show(image);
+ gtk_box_pack_start(GTK_BOX(text_hbox), prev_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(prev_btn), "Previous sentence");
+ gtk_widget_set_sensitive(GTK_WIDGET(prev_btn), FALSE);
+ g_signal_connect(G_OBJECT(prev_btn), "clicked", G_CALLBACK(find_prev_btn_click), (gpointer) find_entry);
+ gtk_widget_show(prev_btn);
+
+ next_btn = gtk_button_new();
+ image = gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON);
+ gtk_container_add(GTK_CONTAINER(next_btn), image);
+ gtk_widget_show(image);
+ gtk_box_pack_start(GTK_BOX(text_hbox), next_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(next_btn), "Next sentence");
+ gtk_widget_set_sensitive(GTK_WIDGET(next_btn), FALSE);
+ g_signal_connect(G_OBJECT(next_btn), "clicked", G_CALLBACK(find_next_btn_click), (gpointer) find_entry);
+ gtk_widget_show(next_btn);
+
+ clear_btn = gtk_button_new();
+ image = gtk_image_new_from_stock(GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON);
+ gtk_container_add(GTK_CONTAINER(clear_btn), image);
+ gtk_widget_show(image);
+ gtk_box_pack_start(GTK_BOX(text_hbox), clear_btn, FALSE, FALSE, 0);
+ gtk_widget_set_tooltip_text(GTK_WIDGET(clear_btn), "Cleanup highlighting");
+ gtk_widget_set_sensitive(GTK_WIDGET(clear_btn), FALSE);
+ g_signal_connect(G_OBJECT(clear_btn), "clicked", G_CALLBACK(clear_btn_click), (gpointer) find_entry);
+ gtk_widget_show(clear_btn);
 
-  return popup_menu;
-}*/
+ statusbar = gtk_statusbar_new();
+ gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
+ gtk_widget_show(statusbar);
+}
 
 static GtkWidget *gtk_button_new_with_label_and_image(gchar *img_name, gchar *label_text)
 {
@@ -180,3 +208,134 @@ static GtkWidget *gtk_button_new_with_label_and_image(gchar *img_name, gchar *la
  return button;
 }
 
+void add_sentence(char *sentence)
+{
+ GtkTextBuffer *buffer;
+ GtkTextIter iter;
+
+ 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);
+}
+
+void clear_sentences()
+{
+ GtkTextBuffer *buffer;
+ gchar text[] = "\0";
+
+ buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sentences_text));
+ gtk_text_buffer_set_text(buffer, text, -1);
+}
+
+void search_sentences(const gchar *word)
+{
+ GtkTextBuffer *buffer;
+ GtkTextIter find_start, find_end;
+ GtkTextIter match_start, match_end;
+ int offset;
+
+ 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); 
+ gtk_text_buffer_remove_tag_by_name(buffer, "yellow-bg", &find_start, &find_end);
+ while (gtk_text_iter_forward_search(&find_start, word, GTK_TEXT_SEARCH_TEXT_ONLY| 
+									 GTK_TEXT_SEARCH_VISIBLE_ONLY, &match_start,
+									 &match_end, NULL)) {
+	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);
+ }
+ gtk_text_buffer_get_start_iter(buffer, &find_start);
+ gtk_text_buffer_get_end_iter(buffer, &find_end);
+ if (gtk_text_iter_forward_search(&find_start, word, GTK_TEXT_SEARCH_TEXT_ONLY| 
+								 GTK_TEXT_SEARCH_VISIBLE_ONLY, &match_start,
+								 &match_end, NULL)) {
+	gtk_text_buffer_apply_tag_by_name(buffer, "green-bg", &match_start, &match_end);
+	current_highlighted_end = gtk_text_iter_get_offset(&match_end);
+	current_highlighted_start = gtk_text_iter_get_offset(&match_start);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(sentences_text), &match_start, 0.0, TRUE, 0.5, 0.5);	
+ }
+}
+
+void enable_search()
+{
+ gtk_widget_set_sensitive(GTK_WIDGET(find_label), TRUE);
+ gtk_widget_set_sensitive(GTK_WIDGET(find_entry), TRUE);
+}
+
+void change_search_navigation_state(gboolean state)
+{
+ gtk_widget_set_sensitive(GTK_WIDGET(prev_btn), state);
+ gtk_widget_set_sensitive(GTK_WIDGET(next_btn), state);
+ gtk_widget_set_sensitive(GTK_WIDGET(clear_btn), state);
+}
+
+void set_find_text(gchar *text)
+{
+ gtk_entry_set_text(GTK_ENTRY(find_entry), text);
+}
+
+void clear_search_tags()
+{
+ GtkTextBuffer *buffer;
+ GtkTextIter find_start, find_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);
+}
+
+void find_next(const gchar *word)
+{
+ GtkTextBuffer *buffer;
+ GtkTextIter find_start, find_end;
+ GtkTextIter match_start, match_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, "green-bg", &find_start, &find_end);
+ gtk_text_buffer_get_iter_at_offset(buffer, &find_start, current_highlighted_end);
+ if (gtk_text_iter_forward_search(&find_start, word, GTK_TEXT_SEARCH_TEXT_ONLY| 
+								 GTK_TEXT_SEARCH_VISIBLE_ONLY, &match_start,
+								 &match_end, NULL)) {
+	gtk_text_buffer_apply_tag_by_name(buffer, "green-bg", &match_start, &match_end);
+	current_highlighted_start = gtk_text_iter_get_offset(&match_start);
+	current_highlighted_end = gtk_text_iter_get_offset(&match_end);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(sentences_text), &match_start, 0.0, TRUE, 0.5, 0.5);
+ } else {
+	gtk_text_buffer_get_end_iter(buffer, &find_end);
+	current_highlighted_start = gtk_text_iter_get_offset(&find_end);
+	current_highlighted_end = gtk_text_iter_get_offset(&find_end);
+ }
+}
+
+void find_prev(const gchar *word)
+{
+ GtkTextBuffer *buffer;
+ GtkTextIter find_start, find_end;
+ GtkTextIter match_start, match_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, "green-bg", &find_start, &find_end);
+ gtk_text_buffer_get_iter_at_offset(buffer, &find_end, current_highlighted_start);
+ if (gtk_text_iter_backward_search(&find_end, word, GTK_TEXT_SEARCH_TEXT_ONLY| 
+								 GTK_TEXT_SEARCH_VISIBLE_ONLY, &match_start,
+								 &match_end, NULL)) {
+	gtk_text_buffer_apply_tag_by_name(buffer, "green-bg", &match_start, &match_end);
+	current_highlighted_start = gtk_text_iter_get_offset(&match_start);
+	current_highlighted_end = gtk_text_iter_get_offset(&match_end);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(sentences_text), &match_start, 0.0, TRUE, 0.5, 0.5);
+ } else {
+	gtk_text_buffer_get_start_iter(buffer, &find_start);
+	current_highlighted_start = gtk_text_iter_get_offset(&find_start);
+	current_highlighted_end = gtk_text_iter_get_offset(&find_start);	
+ }
+}
+
diff --git a/interface.h b/interface.h
index 2a2cb18..2b444ea 100644
--- a/interface.h
+++ b/interface.h
@@ -19,6 +19,19 @@
 #ifndef INTERFACE_H
 #define INTERFACE_H
 
-GtkWidget *create_main_window();
+#include <gtk/gtk.h>
+#include "listview.h"
+
+GtkWidget *main_window;
+void create_main_window();
+void add_sentence(char *);
+void clear_sentences();
+void search_sentences(const gchar *);
+void enable_search();
+void change_search_navigation_state(gboolean);
+void set_find_text(gchar *);
+void clear_search_tags();
+void find_next(const gchar *word);
+void find_prev(const gchar *word);
 
 #endif /*INTERFACE_H*/
diff --git a/listview.c b/listview.c
new file mode 100644
index 0000000..8e3d35a
--- /dev/null
+++ b/listview.c
@@ -0,0 +1,162 @@
+/* This file is a part of WordExtract project
+ *
+ * Copyright (C) 2009 Borisov Alexandr
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "interface.h"
+
+enum {WORD_ITEM = 0, N_COLUMNS};
+
+static GtkWidget *word_list;
+static GtkListStore *store_model;
+
+static GtkWidget *create_popup_menu(void);
+static void init_word_list();
+static void word_list_popup(GtkWidget *widget, GdkEventButton *event);
+static gboolean popup_by_click(GtkWidget *word_list, GdkEventButton *event, gpointer data);
+static gboolean popup_by_keybd(GtkWidget *word_list, gpointer data);
+static void show_sent_item_click(GtkWidget *widget, gpointer data);
+static void add_to_dict_item_click(GtkWidget *widget, gpointer data);
+
+GtkWidget *create_word_list()
+{
+ 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);
+ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(word_list), TRUE);
+ g_signal_connect(G_OBJECT(word_list), "button-press-event", G_CALLBACK(popup_by_click), NULL);
+ g_signal_connect(G_OBJECT(word_list), "popup-menu", G_CALLBACK(popup_by_keybd), NULL);
+ init_word_list(word_list);
+ return word_list;
+}
+
+static void init_word_list()
+{
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *column;
+
+ 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_set(renderer, "editable", TRUE, NULL);
+ 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);
+}
+
+GtkWidget *create_popup_menu(void)
+{
+ GtkWidget *popup_menu;
+ GtkWidget *show_sent_item;
+ GtkWidget *find_image;
+ GtkWidget *add_to_dict_item;
+ GtkWidget *add_image;
+
+ popup_menu = gtk_menu_new();
+
+ 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");
+ 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);
+
+ 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");
+ 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);
+
+ return popup_menu;
+}
+
+void clear_word_list()
+{
+ gtk_list_store_clear(store_model);
+}
+
+void add_word_to_list(char *word)
+{
+ GtkTreeIter iter;
+
+ gtk_list_store_append(store_model, &iter);
+ gtk_list_store_set(store_model, &iter, WORD_ITEM, word, -1);
+}
+
+static void word_list_popup(GtkWidget *widget, GdkEventButton *event)
+{
+ GtkWidget *popup_menu;
+
+ popup_menu = create_popup_menu();
+ gtk_widget_show(popup_menu);
+ gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL, NULL, NULL,
+				(event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent*)event));
+}
+
+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));
+	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)) {
+			gtk_tree_selection_unselect_all(selection);
+			gtk_tree_selection_select_path(selection, path);
+			word_list_popup(GTK_WIDGET(word_list), event);
+			return TRUE;
+		}
+	}
+ }
+return FALSE;
+}
+
+static gboolean popup_by_keybd(GtkWidget *word_list, gpointer data)
+{
+ word_list_popup(word_list, NULL);
+ return TRUE;
+}
+
+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));
+ if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
+	gtk_tree_model_get(model, &iter, 0, &word, -1);
+	set_find_text(word);
+	change_search_navigation_state(TRUE);
+	search_sentences(word);
+	g_free(word);
+ }
+}
+
+void add_to_dict_item_click(GtkWidget *widget, gpointer data)
+{
+
+}
+
+
diff --git a/listview.h b/listview.h
new file mode 100644
index 0000000..4cf0447
--- /dev/null
+++ b/listview.h
@@ -0,0 +1,26 @@
+/* This file is a part of WordExtract project
+ *
+ * Copyright (C) 2009 Borisov Alexandr
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIST_VIEW_H
+#define LIST_VIEW_H
+
+GtkWidget *create_word_list();
+void clear_word_list();
+void add_word_to_list(char *);
+
+#endif /*LIST_VIEW_H*/
diff --git a/main.c b/main.c
index 349942d..79c744f 100644
--- a/main.c
+++ b/main.c
@@ -17,15 +17,12 @@
  */
 
 #include <sys/stat.h>
-#include <gtk/gtk.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "interface.h"
-#include "dict.h"
-#include "word.h"
 #include "subtitle.h"
-#include "srt.h"
+#include "dict.h"
 
 #define PROGNAME "wordextract"
 #define OPT_FOLDER "/.wordextract"
@@ -33,50 +30,20 @@
 
 Language lang;
 
-void create_dict_file(char *path);
+static void create_dict_file(char *);
+static void open_and_load_dict();
 
 int main(int argc, char *argv[])
 {
- GtkWidget *main_window;
- FILE *subtitle;
- FILE *fdict;
- char optpath[PATH_LENGTH] = {0};
- char dictfile[PATH_LENGTH] = {0};
 
  gtk_init(&argc, &argv);
-
- strcpy(optpath, getenv("HOME"));
- strcat(optpath, OPT_FOLDER);
- strcat(dictfile, optpath);
- strcat(dictfile, DICT_FILE);
- if (!(fdict = fopen(dictfile, "r"))) {
-	perror(dictfile);
-	create_dict_file(optpath);
-	if (!(fdict = fopen(dictfile, "r"))) {
-		perror(dictfile);
-		exit(1);
-	}
- }
- dict = load_dict(fdict); 
+ open_and_load_dict();
  lang = ENG;
-
- main_window = create_main_window();
+ create_main_window();
  gtk_widget_show(main_window);
-
- /*main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title(GTK_WINDOW(main_window), "WordExtract");
- gtk_window_set_default_size(GTK_WINDOW(main_window), 800, 600);
- gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER);
- gtk_widget_show(main_window);*/
-
  gtk_main();
 
- //TODO: process subtitle extension to detect format 
- //process_srt(subtitle);
- //print_words(words);
- //fclose(subtitle);
  free_words(dict);
- fclose(fdict);
  return 0;
 }
 
@@ -104,3 +71,24 @@ void create_dict_file(char *path)
 	fclose(fdict);
 }
 
+void open_and_load_dict()
+{
+ FILE *fdict;
+ char optpath[PATH_LENGTH] = {0};
+ char dictfile[PATH_LENGTH] = {0};
+
+ strcpy(optpath, getenv("HOME"));
+ strcat(optpath, OPT_FOLDER);
+ strcat(dictfile, optpath);
+ strcat(dictfile, DICT_FILE);
+ if (!(fdict = fopen(dictfile, "r"))) {
+	perror(dictfile);
+	create_dict_file(optpath);
+	if (!(fdict = fopen(dictfile, "r"))) {
+		perror(dictfile);
+		exit(1);
+	}
+ }
+ dict = load_dict(fdict); 
+ fclose(fdict);
+}
diff --git a/word.c b/word.c
index e6570c7..25d4ff1 100644
--- a/word.c
+++ b/word.c
@@ -19,11 +19,12 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include "interface.h"
 #include "word.h"
 #include "dict.h"
 
-inline char *wordcpy(char *word);
-inline void free_word_record(Word *record);
+static inline char *wordcpy(char *word);
+static inline void free_word_record(Word *record);
 
 int to_list(char *word)
 {
@@ -66,17 +67,17 @@ void print_words(Word *root)
  if (root != NULL) {
 	print_words(root->lsibl);
 	print_words(root->rsibl);
-	printf("%s\n", root->word);
+	add_word_to_list(root->word);
  }
 }
 
-inline void free_word_record(Word *record)
+static inline void free_word_record(Word *record)
 {
  free(record->word);
  free(record);
 }
 
-inline char *wordcpy(char *word)
+static inline char *wordcpy(char *word)
 {
  char *p;
  p = malloc(strlen(word)+1);
diff --git a/word.h b/word.h
index 43d1a81..c5f9567 100644
--- a/word.h
+++ b/word.h
@@ -33,9 +33,9 @@ typedef struct word Word;
 
 Word *words;
 
-int to_list(char *word);
-void print_words(Word *root);
-Word *add_word_record(Word *root, char *word);
-void free_words(Word *root);
+int to_list(char *);
+void print_words(Word *);
+Word *add_word_record(Word *, char *);
+void free_words(Word *);
 
 #endif /*WORD_H*/