diff options
Diffstat (limited to 'src/mainwin.c')
| -rw-r--r-- | src/mainwin.c | 815 |
1 files changed, 815 insertions, 0 deletions
diff --git a/src/mainwin.c b/src/mainwin.c new file mode 100644 index 0000000..4cda3f0 --- /dev/null +++ b/src/mainwin.c @@ -0,0 +1,815 @@ +/* + * This file is part of WordExtract. + * + * Copyright (C) 2009 Borisov Alexandr + * + * WordExtract 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 3 of the License, or + * (at your option) any later version. + * + * 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 + * 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/>. + */ + +#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 +#define SEARCH_BACKWARD 1 +#define ERR_READING_FILE "Could not open the file " +#define ERR_SAVING_FILE "Could not save the file " +#define ERR_MSG_CAPTION "Error" +#define QUIT_MSG_CAPTION "Confirmation" +#define QUIT_MSG_TEXT "Are you sure to exit?" + +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; +static GtkWidget *statusbar; +/*list view variables*/ +static GtkWidget *word_list; +static GtkListStore *store_model; +/*widgets which should be disabled/enabled*/ +static GtkWidget *save_item; +static GtkToolItem *save; +static GtkWidget *find_label; +static GtkWidget *find_entry; +/*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_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); +static void about_item_click(GtkWidget *, gpointer); +static gboolean popup_by_click(GtkWidget *, GdkEventButton *, gpointer); +static gboolean popup_by_keybd(GtkWidget *, gpointer); +static void word_list_popup(GtkWidget *, GdkEventButton *); +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); +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 *, + GtkTextSearchFlags, GtkTextIter *, + GtkTextIter *, const GtkTextIter *, int); +static void find_other(const gchar *, const int); + +void create_main_window() +{ + main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_widget_set_size_request(main_window, 640, 480); + 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), (gpointer) main_window); + g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_window_destroy), NULL); + + GtkWidget *vbox = gtk_vbox_new(FALSE, 2); + gtk_widget_show(vbox); + gtk_container_add(GTK_CONTAINER(main_window), vbox); + + 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_AS, NULL); + gtk_widget_set_sensitive(GTK_WIDGET(save_item), FALSE); + 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); + gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), open_item); + gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_item); + gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), sep_item); + gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit_item); + gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file_item); + gtk_widget_show_all(file_item); + + 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"); + 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); + 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(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); + gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), about_item); + gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help_item); + gtk_widget_show_all(help_item); + + gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2); + gtk_widget_show(menu_bar); + + GtkWidget *toolbar = gtk_toolbar_new(); + gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); + 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_words_item_click), NULL); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), save, -1); + GtkToolItem *tool_sep1 = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep1, -1); + 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 = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep2, -1); + 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 = 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 = 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); + + 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); + 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)); + g_object_unref(store_model); + GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, 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 = 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 = 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); + + sentences_text = gtk_text_view_new(); + 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 = gtk_hbox_new(FALSE, 0); + gtk_box_pack_end(GTK_BOX(text_vbox), text_hbox, FALSE, FALSE, 0); + gtk_widget_show(text_hbox); + + 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); + + 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); + g_signal_connect(G_OBJECT(find_entry), "key-press-event", G_CALLBACK(find_entry_key_press), NULL); + gtk_widget_show(find_entry); + + 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); + 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); + + 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) +{ + gint response = TRUE; + + 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) + response = FALSE; + gtk_widget_destroy(dialog); + + return response; +} + +static void main_window_destroy(GtkWidget *widget, gpointer data) +{ + gtk_main_quit(); +} + +static void open_item_click(GtkWidget *widget, gpointer data) +{ + char *filename; + char *errstr; + FILE *subtitle; + + 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)"); + 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)); + 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); + 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); + free(errstr); + return ; + } + if (words != NULL) { + 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); + 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_words_item_click(GtkWidget *widget, gpointer data) +{ + FILE *savefile; + gchar *filename; + gchar *errstr; + + 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)); + 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); + free(errstr); + return ; + } + save_words(savefile, user_words, save_user_words); + fclose(savefile); + } + gtk_widget_destroy(filedialog); +} + +static void save_text_item_click(GtkWidget *widget, gpointer data) +{ + FILE *savefile; + gchar *filename; + gchar *errstr; + gchar *text; + + 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) { + gtk_widget_destroy(dialog); + gtk_main_quit(); + } + else + gtk_widget_destroy(dialog); +} + +static void dict_item_click(GtkWidget *widget, gpointer data) +{ + create_dict_win(); +} + +static void pref_item_click(GtkWidget *widget, gpointer data) +{ + create_conf_win(); +} + +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[] = {"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", + "version", "v0.2", + "website", "http://null.net", + "comments", comment, + "copyright", copyright, + "license", gplv3, + "authors", authors, + "documenters", NULL, + "translator-credits", NULL, + "logo", NULL, NULL); +} + +static gboolean popup_by_click(GtkWidget *word_list, GdkEventButton *event, gpointer data) +{ + GtkTreePath *path; + + if (event->type == GDK_BUTTON_PRESS && event->button == 3) { + 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)) { + 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; +} + +static void word_list_popup(GtkWidget *widget, GdkEventButton *event) +{ + 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 = 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 = 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 = 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); + gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL, NULL, NULL, + (event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent*)event)); +} + +static void show_sent_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); + set_find_text(word); + change_search_navigation_state(TRUE); + search_sentences(word); + g_free(word); + } +} + +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) +{ + GtkTreeIter iter; + int cnt, i; + + cnt = get_words_count(words); + for (i = 0; i < cnt; i++) { + gtk_list_store_append(store_model, &iter); + gtk_list_store_set(store_model, &iter, WORD_ITEM, *word_list, -1); + word_list++; + } +} + +static 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 add_sentence(char *sentence) +{ + GtkTextIter iter; + + 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 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; + + 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); +} + +static void find_next_btn_click(GtkWidget *widget, gpointer entry) +{ + const gchar *find_text = NULL; + + find_text = gtk_entry_get_text(GTK_ENTRY(entry)); + find_other(find_text, SEARCH_FORWARD); +} + +static void find_prev_btn_click(GtkWidget *widget, gpointer entry) +{ + const gchar *find_text = NULL; + + find_text = gtk_entry_get_text(GTK_ENTRY(entry)); + find_other(find_text, SEARCH_BACKWARD); +} + +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); +} + +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); +} + +static void search_sentences(const gchar *word) +{ + GtkTextIter find_start, find_end; + GtkTextIter match_start, match_end; + int offset, cnt = 0; + + 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); + gtk_text_buffer_remove_tag_by_name(buffer, "yellow-bg", &find_start, &find_end); + while (gtk_text_iter_search_word(&find_start, word, GTK_TEXT_SEARCH_TEXT_ONLY| + GTK_TEXT_SEARCH_VISIBLE_ONLY, &match_start, + &match_end, NULL, SEARCH_FORWARD)) { + 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| + GTK_TEXT_SEARCH_VISIBLE_ONLY, &match_start, + &match_end, NULL, SEARCH_FORWARD)) { + 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); + } +} + +static void set_find_text(gchar *text) +{ + gtk_entry_set_text(GTK_ENTRY(find_entry), text); +} + +static void clear_search_tags() +{ + 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); + 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 + * SEARCH_CASE_INSENSITIVE flag in GtkTextSearchFlags struct + * which is in their TODO list + */ +static gboolean gtk_text_iter_search_word(const GtkTextIter *iter, const gchar *str, + GtkTextSearchFlags flags, GtkTextIter *match_start, + GtkTextIter *match_end, const GtkTextIter *limit, + const int direction) +{ + GtkTextIter match_start_wcap, match_end_wcap; + gboolean result = FALSE; + int offset, offset_wcap; + gchar *str_wcap; + + str_wcap = malloc((strlen(str)+1)*sizeof(gchar)); + strcpy(str_wcap, str); + /* 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)) + offset = gtk_text_iter_get_offset(match_start); + else + offset = -1; + if (gtk_text_iter_forward_search(iter, str_wcap, flags, &match_start_wcap, &match_end_wcap, limit)) + offset_wcap = gtk_text_iter_get_offset(&match_start_wcap); + else + offset_wcap = -1; + if (((offset_wcap < offset)||(offset == -1))&&(offset_wcap != -1)) { + *match_start = match_start_wcap; + *match_end = match_end_wcap; + } + } else if (direction == SEARCH_BACKWARD) { + if (gtk_text_iter_backward_search(iter, str, flags, match_start, match_end, limit)) + offset = gtk_text_iter_get_offset(match_start); + else + offset = -1; + if (gtk_text_iter_backward_search(iter, str_wcap, flags, &match_start_wcap, &match_end_wcap, limit)) + offset_wcap = gtk_text_iter_get_offset(&match_start_wcap); + else + offset_wcap = -1; + if (offset < offset_wcap) { + *match_start = match_start_wcap; + *match_end = match_end_wcap; + } + } + free(str_wcap); + if ((offset_wcap != -1)||(offset != -1)) + result = TRUE; + return result; +} + +static void find_other(const gchar *word, const int direction) +{ + GtkTextIter find_start, find_end; + GtkTextIter match_start, match_end; + + 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); + if (direction == SEARCH_FORWARD) { + gtk_text_buffer_get_iter_at_offset(buffer, &find_start, current_highlighted_end); + } else if (direction == SEARCH_BACKWARD) { + gtk_text_buffer_get_iter_at_offset(buffer, &find_start, current_highlighted_start); + } + if (gtk_text_iter_search_word(&find_start, word, GTK_TEXT_SEARCH_TEXT_ONLY| + GTK_TEXT_SEARCH_VISIBLE_ONLY, &match_start, + &match_end, NULL, direction)) { + 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 { + if (direction == SEARCH_FORWARD) { + 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); + } else if (direction == SEARCH_BACKWARD) { + 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); + } + } +} + |