]> git.datanom.net - lensdb.git/blobdiff - src/gui.c
Readd missing feature
[lensdb.git] / src / gui.c
index 85b94895940b1796c38933d9c6bc25cdeb64c443..6b55fccd87e2c78e8ed0e9a0a9495f95b7603142 100644 (file)
--- a/src/gui.c
+++ b/src/gui.c
 #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("<span foreground=\"red\" size=\"x-large\"><b>Remove [%s] and all lenses?</b></span>", 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);
                
This page took 1.117826 seconds and 5 git commands to generate.