X-Git-Url: http://git.datanom.net/lensdb.git/blobdiff_plain/7c60663584be170ea036431529ee3a1668d2e2fb..HEAD:/src/gui.c?ds=inline diff --git a/src/gui.c b/src/gui.c index 85b9489..6b55fcc 100644 --- a/src/gui.c +++ b/src/gui.c @@ -28,14 +28,143 @@ #include "gui.h" #include "ui.h" #include "icons.h" +#include "sqlite-storage.h" +#include "scanner.h" +#include "csv.h" static GtkBuilder* builder = NULL; +static const gchar* placeholder_str = " Lens notes"; +static GtkTreeIter cur_iter; +static GtkTreeView* cur_view = NULL; +static gchar* current_filename = NULL; + +typedef enum { + VIEWTYPE_DEFAULT, + VIEWTYPE_SEARCH +} ViewType; + +static const gchar* COMMENT = "The application is release under GPL v3.0 but the C++ " + "Interface used in this application is under its own license " + "which is copied here:\n" + "C++ Interface for ExifTool (by Phil Harvey)\n" + "Copyright © 2013-2019, Phil Harvey (philharvey66 at gmail.com)\n" + "This is software, in whole or part, is free for use in non-commercial " + "applications, provided that this copyright notice is retained in the " + "code. A licensing fee may be required for use in a commercial application.\n" + "Contact Phil Harvey for more information. "; + static void clean(gpointer data) { + g_free(current_filename); g_object_unref(G_OBJECT(builder)); gtk_main_quit(); } +/* + * GTK_MESSAGE_INFO + * GTK_MESSAGE_WARNING + * GTK_MESSAGE_QUESTION + * GTK_MESSAGE_ERROR + * GTK_MESSAGE_OTHER + */ +bool show_message(GtkMessageType type, const gchar* msg) { + GtkWidget* dialog = NULL; + bool response = true; + GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window")); + + if (GTK_MESSAGE_QUESTION != type) { + dialog = gtk_message_dialog_new( + GTK_WINDOW(window), + GTK_DIALOG_DESTROY_WITH_PARENT, + type, + GTK_BUTTONS_OK, + msg + ); + + gtk_dialog_run(GTK_DIALOG(dialog)); + } else { + dialog = gtk_message_dialog_new( + GTK_WINDOW(window), + GTK_DIALOG_DESTROY_WITH_PARENT, + type, + GTK_BUTTONS_YES_NO, + msg + ); + + if (GTK_RESPONSE_YES != gtk_dialog_run(GTK_DIALOG(dialog))) { + response = false; + } + } + gtk_widget_destroy(dialog); + + return response; +} + +static void hide_input_dialog() { + GtkWidget* input_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "input_dialog")); + + GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn")); + gtk_entry_set_text(GTK_ENTRY(entry_sn), ""); + + GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data")); + gtk_entry_set_text(GTK_ENTRY(entry_data), ""); + + GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id")); + gtk_entry_set_text(GTK_ENTRY(entry_id), ""); + + GtkWidget* textview_notes = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_notes)); + gtk_text_buffer_set_text(buffer, "", -1); + + gtk_widget_hide(input_dialog); +} + +static void hide_search_result_dialog() { + GtkWidget* hide_search_result_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_dialog")); + GtkWidget* treeview = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_tree_view")); + GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)); + + gtk_list_store_clear(GTK_LIST_STORE(model)); + + gtk_widget_hide(hide_search_result_dialog); +} + +static void hide_search_dialog() { + GtkWidget* search_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_dialog")); + + GtkWidget* entry_maker = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_maker")); + gtk_entry_set_text(GTK_ENTRY(entry_maker), ""); + + GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_data")); + gtk_entry_set_text(GTK_ENTRY(entry_data), ""); + + gtk_widget_hide(search_dialog); +} + +static gchar* get_image_file() { + gchar* file = NULL; + + GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window")); + GtkWidget* dialog = gtk_file_chooser_dialog_new ("Open File", + GTK_WINDOW(window), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", + GTK_RESPONSE_CANCEL, + "_Open", + GTK_RESPONSE_ACCEPT, + NULL); + + gint res = gtk_dialog_run (GTK_DIALOG (dialog)); + if (res == GTK_RESPONSE_ACCEPT) { + GtkFileChooser* chooser = GTK_FILE_CHOOSER(dialog); + file = gtk_file_chooser_get_filename(chooser); + } + + gtk_widget_destroy (dialog); + + return file; +} + static GdkPixbuf* get_logo() { GdkPixbufLoader *loader = gdk_pixbuf_loader_new(); gdk_pixbuf_loader_write(loader, _45796_200_png, _45796_200_png_size, NULL); @@ -45,7 +174,7 @@ static GdkPixbuf* get_logo() { return pixbuf; } -static GdkPixbuf* get_btn_image() { +static GdkPixbuf* get_btn_image_maker_new() { GdkPixbufLoader *loader = gdk_pixbuf_loader_new(); gdk_pixbuf_loader_write(loader, _45796_50_png, _45796_50_png_size, NULL); gdk_pixbuf_loader_close(loader, NULL); @@ -54,6 +183,305 @@ static GdkPixbuf* get_btn_image() { return pixbuf; } +static GdkPixbuf* get_btn_maker_remove_image() { + GdkPixbufLoader *loader = gdk_pixbuf_loader_new(); + gdk_pixbuf_loader_write(loader, no_camera_png, no_camera_png_size, NULL); + gdk_pixbuf_loader_close(loader, NULL); + GdkPixbuf* pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); + + return pixbuf; +} + +/* +static void cell_edited_callback (GtkCellRendererText *cell, + gchar *path_string, + gchar *new_text, + gpointer user_data) { +} +*/ + +static void add_columns(GtkTreeView* treeview, ViewType type) { + GtkCellRenderer *renderer; + GtkTreeViewColumn *column; + + if (type == VIEWTYPE_SEARCH) { + /* column for maker */ + renderer = gtk_cell_renderer_text_new(); + //g_object_set(renderer, "editable", TRUE, NULL); + //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL); + column = gtk_tree_view_column_new_with_attributes("Maker", + renderer, + "text", + COLUMN_SEARCH_MAKER, + NULL); + gtk_tree_view_append_column(treeview, column); + + /* column for serial number */ + renderer = gtk_cell_renderer_text_new(); + //g_object_set(renderer, "editable", TRUE, NULL); + //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL); + column = gtk_tree_view_column_new_with_attributes("Serial Number", + renderer, + "text", + COLUMN_SEARCH_SN, + NULL); + gtk_tree_view_append_column(treeview, column); + + /* column for lens data */ + renderer = gtk_cell_renderer_text_new(); + //g_object_set(renderer, "editable", TRUE, NULL); + //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL); + column = gtk_tree_view_column_new_with_attributes("Lens data", + renderer, + "text", + COLUMN_SEARCH_DATA, + NULL); + gtk_tree_view_append_column(treeview, column); + + /* column for notes */ + renderer = gtk_cell_renderer_text_new(); + //g_object_set(renderer, "editable", TRUE, NULL); + //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL); + column = gtk_tree_view_column_new_with_attributes("Notes", + renderer, + "text", + COLUMN_SEARCH_NOTES, + NULL); + gtk_tree_view_append_column(treeview, column); + } else { + /* column for serial number */ + renderer = gtk_cell_renderer_text_new(); + //g_object_set(renderer, "editable", TRUE, NULL); + //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL); + column = gtk_tree_view_column_new_with_attributes("Serial Number", + renderer, + "text", + COLUMN_DEFAULT_SN, + NULL); + gtk_tree_view_append_column(treeview, column); + + /* column for lens data */ + renderer = gtk_cell_renderer_text_new(); + //g_object_set(renderer, "editable", TRUE, NULL); + //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL); + column = gtk_tree_view_column_new_with_attributes("Lens data", + renderer, + "text", + COLUMN_DEFAULT_DATA, + NULL); + gtk_tree_view_append_column(treeview, column); + + /* column for notes */ + renderer = gtk_cell_renderer_text_new(); + //g_object_set(renderer, "editable", TRUE, NULL); + //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL); + column = gtk_tree_view_column_new_with_attributes("Notes", + renderer, + "text", + COLUMN_DEFAULT_NOTES, + NULL); + gtk_tree_view_append_column(treeview, column); + } +} + +static void on_row_activated (GtkTreeView* view, + GtkTreePath* path, + GtkTreeViewColumn* col, + gpointer userdata) { + GtkTreeIter iter; + GtkTreeModel *model; + + model = gtk_tree_view_get_model(view); + + if (gtk_tree_model_get_iter(model, &iter, path)) { + cur_iter = iter; + cur_view = view; + Row* row = row_new(); + + gtk_tree_model_get(model, &iter, COLUMN_DEFAULT_ID, &row->id, -1); + gtk_tree_model_get(model, &iter, COLUMN_DEFAULT_SN, &row->sn, -1); + gtk_tree_model_get(model, &iter, COLUMN_DEFAULT_DATA, &row->data, -1); + gtk_tree_model_get(model, &iter, COLUMN_DEFAULT_NOTES, &row->notes, -1); + + //fprintf(stderr, "[id: %i, sn: %i, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes); + GtkWidget* input_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "input_dialog")); + GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn")); + gtk_entry_set_text(GTK_ENTRY(entry_sn), row->sn); + + if (row->data != NULL) { + GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data")); + gtk_entry_set_text(GTK_ENTRY(entry_data), row->data); + } + + GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id")); + gchar* id = g_strdup_printf("%ld", row->id); + gtk_entry_set_text(GTK_ENTRY(entry_id), id); + g_free(id); + + if (row->notes != NULL) { + GtkWidget* textview_notes = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview_notes), GTK_WRAP_WORD); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_notes)); + gtk_text_buffer_set_text(buffer, row->notes, -1); + } + + GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header")); + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); + GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page); + const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child); + gchar* dialog_label = g_strconcat("Details [", label,"] Lens", NULL); + gtk_label_set_text(GTK_LABEL(header), dialog_label); + g_free(dialog_label); + GtkWidget* ok_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_ok")); + gtk_widget_hide(ok_btn); + GtkWidget* scan_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_scan")); + gtk_widget_hide(scan_btn); + GtkWidget* update_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_update")); + gtk_widget_show(update_btn); + GtkWidget* delete_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_delete")); + gtk_widget_show(delete_btn); + GtkWidget* move_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_move")); + gtk_widget_show(move_btn); + + gtk_widget_show_all(input_dialog); + + row_free(row, NULL); + } + +} + +static GtkWidget* add_tab() { + GtkListStore* store = NULL; + GtkWidget* treeview; + GtkWidget* scrolled_window; + + store = gtk_list_store_new(4, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_INT64); + treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); + gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_DEFAULT_DATA); + gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_DEFAULT_SN); + g_signal_connect(treeview, "row-activated", G_CALLBACK(on_row_activated), NULL); + g_object_unref(store); + add_columns(GTK_TREE_VIEW(treeview), VIEWTYPE_DEFAULT); + scrolled_window = gtk_scrolled_window_new (NULL, NULL); + g_object_set(scrolled_window, "vexpand", TRUE, NULL); + gtk_container_add(GTK_CONTAINER(scrolled_window), treeview); + + return scrolled_window; +} + +static void add_row(gint maker, Row* row) { + GtkListStore* store = NULL; + GtkWidget* treeview = NULL; + GtkTreeIter iter; + + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + GtkWidget* scrolled_window = NULL; + Maker* maker_info = get_maker(maker); + //fprintf(stdout, "%lu - %s - %d\n", maker_info->id, maker_info->maker_name, maker_info->page); + if (maker_info->page >= 0) + scrolled_window = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), maker_info->page); + if (scrolled_window == NULL) { + /* new maker */ + GtkWidget* tab_label = gtk_label_new(maker_info->maker_name); + scrolled_window = add_tab(); + treeview = gtk_bin_get_child(GTK_BIN(scrolled_window)); + maker_info->page = gtk_notebook_insert_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label, -1); + if (maker_info->page < 0) { + /* Huston whe have a problem */ + gchar* err = g_strdup_printf("%s: Could not create tab\n", maker_info->maker_name); + fprintf(stderr, err); + show_message(GTK_MESSAGE_ERROR, err); + g_free(err); + } else { + update_maker(maker_info); + } + //fprintf(stdout, "%lu - %s - %d - %p\n", maker_info->id, maker_info->maker_name, maker_info->page, scrolled_window); + maker_free(maker_info); + } else { + treeview = gtk_bin_get_child(GTK_BIN(scrolled_window)); + } + + if (row) { + store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(treeview))); + gtk_list_store_append(store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_DEFAULT_SN, row->sn, + COLUMN_DEFAULT_DATA, row->data, + COLUMN_DEFAULT_NOTES, row->notes, + COLUMN_DEFAULT_ID, row->id, + -1); + } + + gtk_widget_show_all(notebook); +} + +static void create_search_result_dialog(GSList* rows) { + GtkListStore* store; + GtkWidget* treeview = NULL; + GtkTreeIter iter; + + GtkWidget* dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_dialog")); + gtk_widget_set_size_request(dialog, 600, 300); + treeview = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_tree_view")); + store = gtk_list_store_new(5, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_INT64); + gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(store)); + gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_SEARCH_DATA); + gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_SEARCH_SN); + //g_signal_connect(treeview, "row-activated", G_CALLBACK(on_row_activated), NULL); + g_object_unref(store); + add_columns(GTK_TREE_VIEW(treeview), VIEWTYPE_SEARCH); + + for (GSList* elem = rows; elem; elem = elem->next) { + Row* row = elem->data; + gtk_list_store_append(store, &iter); + Maker* maker = get_maker(row->maker); + gtk_list_store_set (store, &iter, + COLUMN_SEARCH_MAKER, maker->maker_name, + COLUMN_SEARCH_SN, row->sn, + COLUMN_SEARCH_DATA, row->data, + COLUMN_SEARCH_NOTES, row->notes, + COLUMN_SEARCH_ID, row->id, + -1); + maker_free(maker); + } + + gtk_widget_show_all(dialog); +} + +static void initialize_notebook() { + GSList* ids = NULL; + GSList* rows = NULL; + + GSList* makers = get_makers(); + for (ids = makers; ids; ids = ids->next) { + gint id = get_maker_id(ids->data); + GSList* lenses = get_lens_by_maker(id); + if (lenses) { + for (rows = lenses; rows; rows = rows->next) { + Row* row = rows->data; + add_row(id, row); + } + g_slist_foreach(lenses, (GFunc)row_free, NULL); + g_slist_free(lenses); + lenses = NULL; + } else { + add_row(id, NULL); + } + } + g_slist_foreach(makers, (GFunc)g_free, NULL); + g_slist_free(makers); +} + G_MODULE_EXPORT void onDestroy(GtkWidget* self, gpointer data) { clean(data); } @@ -71,31 +499,717 @@ G_MODULE_EXPORT void about_show_button_press_event_cb(GtkWidget* self, gpointer } G_MODULE_EXPORT void add_maker_clicked_cb(GtkWidget* self, gpointer data) { + GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window")); + GtkWidget* dialog = gtk_dialog_new_with_buttons("New Maker", + GTK_WINDOW(window), + GTK_DIALOG_DESTROY_WITH_PARENT, + "_Ok", + GTK_RESPONSE_ACCEPT, + "_Cancel", + GTK_RESPONSE_CANCEL, + NULL); + GtkWidget* content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog)); + GtkWidget* maker_entry = gtk_entry_new(); + gtk_container_add(GTK_CONTAINER(content_area), maker_entry); + gtk_widget_show_all (dialog); + + gint res = gtk_dialog_run(GTK_DIALOG(dialog)); + + if (res == GTK_RESPONSE_ACCEPT) { + const gchar* maker = gtk_entry_get_text(GTK_ENTRY(maker_entry)); + gchar* error = NULL; + gint id; + + if ((id = add_maker(maker, &error)) != -1) { + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + GtkWidget* tab_label = gtk_label_new(maker); + GtkWidget* scrolled_window = add_tab(); + gint page = gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label); + if (page < 0) { + // Huston whe have a problem + gchar* err = g_strdup_printf("%s: Could not create tab\n", maker); + fprintf(stderr, err); + show_message(GTK_MESSAGE_ERROR, err); + g_free(err); + } else { + //gint id = get_maker_id(maker); + Maker* maker_info = get_maker(id); + maker_info->page = page; + update_maker(maker_info); + gtk_widget_show_all(notebook); + } + } else { + // Huston whe have a problem + gchar* err = g_strdup_printf("%s: Could not add Maker '%s'\n", error, maker); + fprintf(stderr, err); + show_message(GTK_MESSAGE_ERROR, err); + g_free(err); + } + g_free(error); + } + + gtk_widget_destroy(dialog); } +G_MODULE_EXPORT void del_maker_clicked_cb(GtkWidget* self, gpointer data) { + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); + GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page); + const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child); + + GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window")); + GtkWidget* dialog = gtk_dialog_new_with_buttons("Delete Maker", + GTK_WINDOW(window), + GTK_DIALOG_DESTROY_WITH_PARENT, + "_Ok", + GTK_RESPONSE_ACCEPT, + "_Cancel", + GTK_RESPONSE_CANCEL, + NULL); + GtkWidget* content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog)); + GtkWidget* maker_label = gtk_label_new(NULL); + gchar* warning = g_strdup_printf("Remove [%s] and all lenses?", label); + gtk_label_set_markup(GTK_LABEL(maker_label), warning); + g_free(warning); + gtk_container_add(GTK_CONTAINER(content_area), maker_label); + gtk_widget_show_all (dialog); + + gint res = gtk_dialog_run(GTK_DIALOG(dialog)); + + if (res == GTK_RESPONSE_ACCEPT) { + gchar* error = NULL; + + if (!delete_maker(label, &error)) { + notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), cur_page); + gtk_widget_show_all(notebook); + } else { + // Huston whe have a problem + gchar* err = g_strdup_printf("%s: Could not remove Maker '%s'\n", error, label); + fprintf(stderr, err); + show_message(GTK_MESSAGE_ERROR, err); + g_free(err); + } + g_free(error); + } + + gtk_widget_destroy(dialog); +} + + G_MODULE_EXPORT void add_lens_clicked_cb(GtkWidget* self, gpointer data) { + GtkWidget* input_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "input_dialog")); + GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header")); + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); + GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page); + const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child); + gchar* dialog_label = g_strconcat("New [", label,"] Lens", NULL); + gtk_label_set_text(GTK_LABEL(header), dialog_label); + g_free(dialog_label); + + GtkWidget* ok_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_ok")); + gtk_widget_show(ok_btn); + GtkWidget* scan_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_scan")); + gtk_widget_show(scan_btn); + GtkWidget* update_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_update")); + gtk_widget_hide(update_btn); + GtkWidget* delete_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_delete")); + gtk_widget_hide(delete_btn); + GtkWidget* move_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_move")); + gtk_widget_hide(move_btn); + + gtk_widget_show_all(input_dialog); } G_MODULE_EXPORT void find_lens_clicked_cb(GtkWidget* self, gpointer data) { + GtkWidget* search_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_dialog")); + gtk_widget_show_all(search_dialog); +} + +G_MODULE_EXPORT void search_close_clicked_cb(GtkWidget* self, gpointer data) { + hide_search_dialog(); +} + +G_MODULE_EXPORT void search_ok_clicked_cb(GtkWidget* self, gpointer data) { + Row* row = row_new(); + GtkWidget* entry_maker = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_maker")); + row->notes = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_maker))); + + GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_data")); + row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data))); + + GSList* rows = get_lens_by_search(row); + row_free(row, NULL); + + create_search_result_dialog(rows); + + g_slist_foreach(rows, (GFunc)row_free, NULL); + g_slist_free(rows); + + hide_search_dialog(); +} + +G_MODULE_EXPORT gboolean on_textview_input_notes_focus_in_event(GtkWidget* self, GtkBuilder* data) { + GtkTextIter start, end; + GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + const gchar* buf = gtk_text_buffer_get_text(buffer, &start, &end, FALSE); + if (g_strcmp0(placeholder_str, buf) == 0) + gtk_text_buffer_set_text(buffer, "", -1); + return FALSE; +} + +G_MODULE_EXPORT gboolean on_textview_input_notes_focus_out_event(GtkWidget* self, GtkBuilder* data) { + GtkTextIter start, end; + GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + const gchar* buf = gtk_text_buffer_get_text (buffer, &start, &end, FALSE); + if (g_strcmp0("", buf) == 0) + gtk_text_buffer_set_text(buffer, placeholder_str, -1); + return FALSE; +} + +G_MODULE_EXPORT void input_close_clicked_cb(GtkWidget* self, GtkBuilder* data) { + hide_input_dialog(); +} + +G_MODULE_EXPORT void input_ok_clicked_cb(GtkWidget* self, gpointer data) { + Row* row = row_new(); + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); + GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page); + const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child); + + row->maker = get_maker_id(label); + + GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn")); + row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn))); + + GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data")); + row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data))); + + GtkTextIter start, end; + GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE)); + + /* New lens */ + if (add_lens(row)) { + gchar* err = g_strdup_printf("Add failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes); + fprintf(stderr, err); + show_message(GTK_MESSAGE_ERROR, err); + g_free(err); + } else { + GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id")); + gtk_entry_set_text(GTK_ENTRY(entry_id), g_strdup_printf("%lu", row->id)); + + add_row(get_maker_id(label), row); + } + + row_free(row, NULL); + cur_view = NULL; + + hide_input_dialog(); +} + +G_MODULE_EXPORT void input_scan_clicked_cb(GtkWidget* self, gpointer data) { + Row* row = row_new(); + + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); + GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page); + const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child); + + gchar* path = get_image_file(); + if (path) { + GtkWidget* close_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_close")); + g_object_set(G_OBJECT(close_btn), "can-default", TRUE, "has-default", TRUE, NULL); + + Scanner_t* sc = scanner_create(path); + + gchar* sn = get_lens_serial_number(sc); + GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn")); + gtk_entry_set_text(GTK_ENTRY(entry_sn), g_strdup(sn)); + //row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn))); + g_free(sn); + + gchar* data = get_lens_info(sc); + GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data")); + gtk_entry_set_text(GTK_ENTRY(entry_data), g_strdup(data)); + //row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data))); + g_free(data); + + gchar* lens_maker = get_lens_maker(sc); + //GtkTextIter start, end; + GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); + gtk_text_buffer_set_text(buffer, g_strdup_printf("Data Scanned from %s", path), -1); + //row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE)); + + scanner_destroy(sc); + + /* New lens */ + /* + * 1. Create maker if not exist + * 2. Change tab if maker is is not current tab + * 3. Update input_label to the current tab + */ + GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header")); + Maker* maker = NULL; + gchar* dialog_label = NULL; + + if (lens_maker) { + gint id; + + if (label && g_ascii_strcasecmp(label, lens_maker) == 0) { + /* lens_maker same as than current maker */ + } else { + id = get_maker_id(lens_maker); + if (id != -1) { + /* Change tab */ + maker = get_maker(id); + gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), maker->page); + dialog_label = g_strconcat("New [", maker->maker_name,"] Lens", NULL); + gtk_label_set_text(GTK_LABEL(header), dialog_label); + g_free(dialog_label); + } else { + /* Ask to add to current maker */ + gchar* error = NULL; + + id = add_maker(lens_maker, &error); + if (id != -1) { + add_row(id, NULL); + maker = get_maker(id); + gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), maker->page); + dialog_label = g_strconcat("New [", maker->maker_name,"] Lens", NULL); + gtk_label_set_text(GTK_LABEL(header), dialog_label); + g_free(dialog_label); + } + g_free(error); + } + } + } else { + /* New lens for current maker */ + } + maker_free(maker); + g_free(lens_maker); + } + + g_free(path); + row_free(row, NULL); +} + +G_MODULE_EXPORT void input_delete_clicked_cb(GtkWidget* self, gpointer data) { + Row* row = row_new(); + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); + GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page); + const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child); + + row->maker = get_maker_id(label); + + GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id")); + row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id))); + if (cur_view != NULL) { + if (delete_lens(row)) { + gchar* err = g_strdup_printf("Delete failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes); + fprintf(stderr, err); + show_message(GTK_MESSAGE_ERROR, err); + g_free(err); + } + GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view)); + gtk_list_store_remove(store, &cur_iter); + } + + row_free(row, NULL); + cur_view = NULL; + + hide_input_dialog(); +} + +G_MODULE_EXPORT void input_update_clicked_cb(GtkWidget* self, gpointer data) { + Row* row = row_new(); + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); + GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page); + const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child); + + row->maker = get_maker_id(label); + + GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id")); + row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id))); + + GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn")); + row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn))); + + GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data")); + row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data))); + + GtkTextIter start, end; + GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE)); + + if (cur_view != NULL) { + if (update_lens(row)) { + gchar* err = g_strdup_printf("Update failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes); + fprintf(stderr, err); + show_message(GTK_MESSAGE_ERROR, err); + g_free(err); + } + GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view)); + gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_SN, row->sn, -1); + gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_DATA, row->data, -1); + gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_NOTES, row->notes, -1); + } + + row_free(row, NULL); + cur_view = NULL; + + hide_input_dialog(); +} + +G_MODULE_EXPORT void input_move_clicked_cb(GtkWidget* self, gpointer data) { + GtkWidget *dialog, *content_area, *combo; + + GtkWidget* parent = GTK_WIDGET(gtk_builder_get_object(builder, "main_window")); + GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT; + dialog = gtk_dialog_new_with_buttons("New Maker", + GTK_WINDOW(parent), + flags, + "_OK", + GTK_RESPONSE_ACCEPT, + "_Cancel", + GTK_RESPONSE_REJECT, + NULL); + + content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); + combo = gtk_combo_box_text_new(); + GSList* makers = get_makers(); + + for (GSList* elem = makers; elem; elem = elem->next) { + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), g_strdup((const gchar*)elem->data)); + } + gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0); + gtk_widget_show_all(combo); + + g_slist_foreach(makers, (GFunc)g_free, NULL); + g_slist_free(makers); + + gtk_container_add(GTK_CONTAINER(content_area), combo); + + gint response = gtk_dialog_run(GTK_DIALOG(dialog)); + if (response == GTK_RESPONSE_ACCEPT) { + Row* row = row_new(); + + gchar* maker = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo)); + row->maker = get_maker_id(maker); + g_free(maker); + + GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id")); + row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id))); + + GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn")); + row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn))); + + GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data")); + row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data))); + + GtkTextIter start, end; + GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE)); + + if (cur_view != NULL) { + if (update_lens_maker(row)) { + gchar* err = g_strdup_printf("Update failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes); + fprintf(stderr, err); + show_message(GTK_MESSAGE_ERROR, err); + g_free(err); + } + GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view)); + gtk_list_store_remove(store, &cur_iter); + add_row(row->maker, row); + } + + row_free(row, NULL); + cur_view = NULL; + } + gtk_widget_destroy(dialog); + + hide_input_dialog(); +} + +G_MODULE_EXPORT void search_result_ok_clicked_cb(GtkWidget* self, gpointer data) { + hide_search_result_dialog(); +} + +typedef enum { + FILE_SAVE_AS, + FILE_SAVE, + FILE_NEW, + FILE_OPEN +} FileAction; + +static gchar* get_filename(FileAction fileAction, const gchar* title) { + GtkWidget *dialog; + GtkFileChooser *chooser; + GtkFileChooserAction action; + gint res; + GtkWidget* parent_window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window")); + gchar* nameHint = NULL; + gchar* current_dir = NULL; + + if (current_filename != NULL) { + current_dir = g_path_get_dirname(current_filename); + nameHint = g_path_get_basename(current_filename); + } + switch (fileAction) { + case FILE_SAVE_AS: + g_free(nameHint); + nameHint = g_strdup("Untitled document.csv"); + action = GTK_FILE_CHOOSER_ACTION_SAVE; + break; + case FILE_SAVE: + if (nameHint == NULL) + nameHint = g_strdup("Untitled document.csv"); + action = GTK_FILE_CHOOSER_ACTION_SAVE; + break; + case FILE_NEW: + g_free(nameHint); + nameHint = g_strdup("Untitled document.csv"); + action = GTK_FILE_CHOOSER_ACTION_SAVE; + break; + case FILE_OPEN: + action = GTK_FILE_CHOOSER_ACTION_OPEN; + break; + } + + if (FILE_OPEN == fileAction) { + dialog = gtk_file_chooser_dialog_new(title, + GTK_WINDOW(parent_window), + action, + ("_Cancel"), + GTK_RESPONSE_CANCEL, + ("_Open"), + GTK_RESPONSE_ACCEPT, + NULL); + } else { + dialog = gtk_file_chooser_dialog_new(title, + GTK_WINDOW(parent_window), + action, + ("_Cancel"), + GTK_RESPONSE_CANCEL, + ("_Save"), + GTK_RESPONSE_ACCEPT, + NULL); + } + + chooser = GTK_FILE_CHOOSER(dialog); + + GtkFileFilter* filter_csv = gtk_file_filter_new(); + gtk_file_filter_add_mime_type(filter_csv, "text/csv"); + gtk_file_filter_add_mime_type(filter_csv, "application/csv"); + gtk_file_filter_add_mime_type(filter_csv, "application/x-csv"); + gtk_file_filter_add_mime_type(filter_csv, "application/vnd.ms-excel"); + gtk_file_filter_add_mime_type(filter_csv, "text/x-csv"); + gtk_file_filter_add_mime_type(filter_csv, "text/comma-separated-values"); + gtk_file_filter_add_mime_type(filter_csv, "text/x-comma-separated-values"); + gtk_file_filter_add_mime_type(filter_csv, "text/tab-separated-values"); + gtk_file_filter_add_pattern(filter_csv, "*.csv"); + gtk_file_filter_set_name(filter_csv, "CSV files"); + gtk_file_chooser_add_filter(chooser, filter_csv); + GtkFileFilter* filter_plain = gtk_file_filter_new(); + gtk_file_filter_add_mime_type(filter_plain, "text/plain"); + gtk_file_filter_set_name(filter_plain, "Plain text"); + gtk_file_chooser_add_filter(chooser, filter_plain); + + if (FILE_OPEN != fileAction) { + gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE); + GtkFileFilter* filter_all = gtk_file_filter_new(); + gtk_file_filter_add_pattern(filter_all, "*"); + gtk_file_filter_set_name(filter_all, "All files"); + gtk_file_chooser_add_filter(chooser, filter_all); + gtk_file_chooser_set_current_name(chooser, nameHint); + } + + if (current_dir != NULL) + gtk_file_chooser_set_current_folder(chooser, current_dir); + + res = gtk_dialog_run(GTK_DIALOG(dialog)); + if (res == GTK_RESPONSE_ACCEPT) { + g_free(current_filename); + current_filename = gtk_file_chooser_get_filename(chooser); + } + + gtk_widget_destroy (dialog); + g_free(nameHint); + g_free(current_dir); + + return res == GTK_RESPONSE_ACCEPT ? g_strdup(current_filename) : NULL; +} + +void commit(const gchar* filename) { + CvsError* err = NULL; + + if (filename) { + Instructions instructions = { + .file = filename, + .write = true, + .overwrite = true, + .first_line_header = true + }; + CsvParser* parser = csv_parser_new(&instructions, &err); + if (parser) { + dump_storage(parser); + csv_parser_free(parser); + } else { + fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message); + csv_error_clear(&err); + } + } +} + +G_MODULE_EXPORT void onSaveAs(GtkWidget* self, gpointer data) { + gchar* filename = get_filename(FILE_NEW, "New File"); + commit(filename); + g_free(filename); +} + +G_MODULE_EXPORT void onOpen(GtkWidget* self, gpointer data) { + CvsError* err = NULL; + gchar* cvsErr = NULL; + bool replace = false; + GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook")); + + gchar* filename = get_filename(FILE_OPEN, "Open File"); + if (filename) { + Instructions instructions = { + .file = filename, + .first_line_header = true, + .write = false, + .overwrite = false + }; + CsvParser* parser = csv_parser_new(&instructions, &err); + if (!parser) { + fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message); + csv_error_clear(&err); + } else { + if ((replace = show_message(GTK_MESSAGE_QUESTION, "Should file content replace current?")) == true) { + for (gint i = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook)); i > 0; i--) { + GtkWidget* window = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), i-1); + GtkWidget* treeview = gtk_bin_get_child(GTK_BIN(window)); + GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)); + GtkListStore* store = GTK_LIST_STORE(model); + gtk_list_store_clear(store); + //gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), NULL); + gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), i-1); + gtk_widget_queue_draw(GTK_WIDGET(notebook)); + } + GSList* makers = get_makers(); + for (GSList* elem = makers; elem; elem = elem->next) { + Maker* maker = get_maker(get_maker_id(elem->data)); + delete_maker(maker->maker_name, &cvsErr); + maker_free(maker); + } + g_slist_foreach(makers, (GFunc)g_free, NULL); + g_slist_free(makers); + } + Record* r = NULL; + while ((r = csv_parser_next_line(parser, &err)) != NULL) { + if (err) { + fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message); + csv_error_clear(&err); + } + gint id; + if ((id = get_maker_id(r->maker)) == -1) { + id = add_maker(r->maker, &cvsErr); + } + Row* row = row_new(); + row->maker = id; + row->sn = g_strdup(r->sn); + row->data = g_strdup(r->data); + row->notes = g_strdup(r->notes); + csv_record_free(r); + add_lens(row); + if (!replace) + add_row(row->maker, row); + row_free(row, NULL); + } + csv_parser_free(parser); + if (replace) + initialize_notebook(); + } + g_free(filename); + } +} + +G_MODULE_EXPORT void onNew(GtkWidget* self, gpointer data) { + gchar* filename = get_filename(FILE_NEW, "New File"); + commit(filename); + g_free(filename); +} + +G_MODULE_EXPORT void onSave(GtkWidget* self, gpointer data) { + gchar* filename = get_filename(FILE_SAVE, "Save File"); + commit(filename); + g_free(filename); } gboolean init_gui() { gboolean fail = TRUE; - builder = gtk_builder_new_from_string(lensdatabase_ui, lensdatabase_ui_len); + builder = gtk_builder_new_from_string((const gchar *) lensdatabase_ui, lensdatabase_ui_size); if (builder != NULL) { fail = FALSE; GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window")); + GtkAccelGroup* accel_group = gtk_accel_group_new(); + gtk_window_add_accel_group(GTK_WINDOW(window), accel_group); + + GtkWidget* menu_item_new = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_new")); + gtk_widget_add_accelerator(menu_item_new, "activate", accel_group, GDK_KEY_n, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + GtkWidget* menu_item_open = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_open")); + gtk_widget_add_accelerator(menu_item_open, "activate", accel_group, GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + GtkWidget* menu_item_save = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_save")); + gtk_widget_add_accelerator(menu_item_save, "activate", accel_group, GDK_KEY_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + GtkWidget* menu_item_save_as = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_save_as")); + gtk_widget_add_accelerator(menu_item_save_as, "activate", accel_group, GDK_KEY_a, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + GtkWidget* menu_item_quit = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_quit")); + gtk_widget_add_accelerator(menu_item_quit, "activate", accel_group, GDK_KEY_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + GtkWidget* add_maker = GTK_WIDGET(gtk_builder_get_object(builder, "add_maker")); - GtkWidget* image = gtk_image_new_from_pixbuf(get_btn_image()); - gtk_button_set_image(GTK_BUTTON(add_maker), image); + GtkWidget* add_image = gtk_image_new_from_pixbuf(get_btn_image_maker_new()); + gtk_button_set_image(GTK_BUTTON(add_maker), add_image); + GtkWidget* del_maker = GTK_WIDGET(gtk_builder_get_object(builder, "del_maker")); + GtkWidget* del_image = gtk_image_new_from_pixbuf(get_btn_maker_remove_image()); + gtk_button_set_image(GTK_BUTTON(del_maker), del_image); + GtkWidget* about_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "about_dialog")); gtk_window_set_transient_for(GTK_WINDOW(about_dialog), GTK_WINDOW(window)); + gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(about_dialog), COMMENT); + gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(about_dialog), PACKAGE_NAME); + gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about_dialog), VERSION); + GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes")); + GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); + gtk_text_buffer_set_text(buffer, placeholder_str, -1); + gtk_builder_connect_signals(builder, builder); + + initialize_notebook(); gtk_widget_show(window);