]> git.datanom.net - lensdb.git/blob - src/gui.c
Completed import and export
[lensdb.git] / src / gui.c
1 /*
2 * gui.c
3 *
4 * Copyright 2024 Michael Rasmussen <mir@datanom.net>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19 * MA 02110-1301, USA.
20 *
21 *
22 */
23
24 #ifdef HAVE_CONFIG_H
25 # include <config.h>
26 #endif
27
28 #include "gui.h"
29 #include "ui.h"
30 #include "icons.h"
31 #include "sqlite-storage.h"
32 #include "scanner.h"
33 #include "csv.h"
34
35 static GtkBuilder* builder = NULL;
36 static const gchar* placeholder_str = " Lens notes";
37 static GtkTreeIter cur_iter;
38 static GtkTreeView* cur_view = NULL;
39 static gchar* current_filename = NULL;
40
41 typedef enum {
42 VIEWTYPE_DEFAULT,
43 VIEWTYPE_SEARCH
44 } ViewType;
45
46 static const gchar* COMMENT = "The application is release under GPL v3.0 but the C++ "
47 "Interface used in this application is under its own license "
48 "which is copied here:\n"
49 "C++ Interface for ExifTool (by Phil Harvey)\n"
50 "Copyright © 2013-2019, Phil Harvey (philharvey66 at gmail.com)\n"
51 "This is software, in whole or part, is free for use in non-commercial "
52 "applications, provided that this copyright notice is retained in the "
53 "code. A licensing fee may be required for use in a commercial application.\n"
54 "Contact Phil Harvey for more information. ";
55
56
57 static void clean(gpointer data) {
58 g_free(current_filename);
59 g_object_unref(G_OBJECT(builder));
60 gtk_main_quit();
61 }
62
63 /*
64 * GTK_MESSAGE_INFO
65 * GTK_MESSAGE_WARNING
66 * GTK_MESSAGE_QUESTION
67 * GTK_MESSAGE_ERROR
68 * GTK_MESSAGE_OTHER
69 */
70 bool show_message(GtkMessageType type, const gchar* msg) {
71 GtkWidget* dialog = NULL;
72 bool response = true;
73 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
74
75 if (GTK_MESSAGE_QUESTION != type) {
76 dialog = gtk_message_dialog_new(
77 GTK_WINDOW(window),
78 GTK_DIALOG_DESTROY_WITH_PARENT,
79 type,
80 GTK_BUTTONS_OK,
81 msg
82 );
83
84 gtk_dialog_run(GTK_DIALOG(dialog));
85 } else {
86 dialog = gtk_message_dialog_new(
87 GTK_WINDOW(window),
88 GTK_DIALOG_DESTROY_WITH_PARENT,
89 type,
90 GTK_BUTTONS_YES_NO,
91 msg
92 );
93
94 if (GTK_RESPONSE_YES != gtk_dialog_run(GTK_DIALOG(dialog))) {
95 response = false;
96 }
97 }
98 gtk_widget_destroy(dialog);
99
100 return response;
101 }
102
103 static void hide_input_dialog() {
104 GtkWidget* input_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "input_dialog"));
105
106 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
107 gtk_entry_set_text(GTK_ENTRY(entry_sn), "");
108
109 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
110 gtk_entry_set_text(GTK_ENTRY(entry_data), "");
111
112 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
113 gtk_entry_set_text(GTK_ENTRY(entry_id), "");
114
115 GtkWidget* textview_notes = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
116 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_notes));
117 gtk_text_buffer_set_text(buffer, "", -1);
118
119 gtk_widget_hide(input_dialog);
120 }
121
122 static void hide_search_result_dialog() {
123 GtkWidget* hide_search_result_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_dialog"));
124 GtkWidget* treeview = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_tree_view"));
125 GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
126
127 gtk_list_store_clear(GTK_LIST_STORE(model));
128
129 gtk_widget_hide(hide_search_result_dialog);
130 }
131
132 static void hide_search_dialog() {
133 GtkWidget* search_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_dialog"));
134
135 GtkWidget* entry_maker = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_maker"));
136 gtk_entry_set_text(GTK_ENTRY(entry_maker), "");
137
138 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_data"));
139 gtk_entry_set_text(GTK_ENTRY(entry_data), "");
140
141 gtk_widget_hide(search_dialog);
142 }
143
144 static gchar* get_image_file() {
145 gchar* file = NULL;
146
147 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
148 GtkWidget* dialog = gtk_file_chooser_dialog_new ("Open File",
149 GTK_WINDOW(window),
150 GTK_FILE_CHOOSER_ACTION_OPEN,
151 "_Cancel",
152 GTK_RESPONSE_CANCEL,
153 "_Open",
154 GTK_RESPONSE_ACCEPT,
155 NULL);
156
157 gint res = gtk_dialog_run (GTK_DIALOG (dialog));
158 if (res == GTK_RESPONSE_ACCEPT) {
159 GtkFileChooser* chooser = GTK_FILE_CHOOSER(dialog);
160 file = gtk_file_chooser_get_filename(chooser);
161 }
162
163 gtk_widget_destroy (dialog);
164
165 return file;
166 }
167
168 static GdkPixbuf* get_logo() {
169 GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
170 gdk_pixbuf_loader_write(loader, _45796_200_png, _45796_200_png_size, NULL);
171 gdk_pixbuf_loader_close(loader, NULL);
172 GdkPixbuf* pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
173
174 return pixbuf;
175 }
176
177 static GdkPixbuf* get_btn_image_maker_new() {
178 GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
179 gdk_pixbuf_loader_write(loader, _45796_50_png, _45796_50_png_size, NULL);
180 gdk_pixbuf_loader_close(loader, NULL);
181 GdkPixbuf* pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
182
183 return pixbuf;
184 }
185
186 static GdkPixbuf* get_btn_maker_remove_image() {
187 GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
188 gdk_pixbuf_loader_write(loader, no_camera_png, no_camera_png_size, NULL);
189 gdk_pixbuf_loader_close(loader, NULL);
190 GdkPixbuf* pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
191
192 return pixbuf;
193 }
194
195 /*
196 static void cell_edited_callback (GtkCellRendererText *cell,
197 gchar *path_string,
198 gchar *new_text,
199 gpointer user_data) {
200 }
201 */
202
203 static void add_columns(GtkTreeView* treeview, ViewType type) {
204 GtkCellRenderer *renderer;
205 GtkTreeViewColumn *column;
206
207 if (type == VIEWTYPE_SEARCH) {
208 /* column for maker */
209 renderer = gtk_cell_renderer_text_new();
210 //g_object_set(renderer, "editable", TRUE, NULL);
211 //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL);
212 column = gtk_tree_view_column_new_with_attributes("Maker",
213 renderer,
214 "text",
215 COLUMN_SEARCH_MAKER,
216 NULL);
217 gtk_tree_view_append_column(treeview, column);
218
219 /* column for serial number */
220 renderer = gtk_cell_renderer_text_new();
221 //g_object_set(renderer, "editable", TRUE, NULL);
222 //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL);
223 column = gtk_tree_view_column_new_with_attributes("Serial Number",
224 renderer,
225 "text",
226 COLUMN_SEARCH_SN,
227 NULL);
228 gtk_tree_view_append_column(treeview, column);
229
230 /* column for lens data */
231 renderer = gtk_cell_renderer_text_new();
232 //g_object_set(renderer, "editable", TRUE, NULL);
233 //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL);
234 column = gtk_tree_view_column_new_with_attributes("Lens data",
235 renderer,
236 "text",
237 COLUMN_SEARCH_DATA,
238 NULL);
239 gtk_tree_view_append_column(treeview, column);
240
241 /* column for notes */
242 renderer = gtk_cell_renderer_text_new();
243 //g_object_set(renderer, "editable", TRUE, NULL);
244 //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL);
245 column = gtk_tree_view_column_new_with_attributes("Notes",
246 renderer,
247 "text",
248 COLUMN_SEARCH_NOTES,
249 NULL);
250 gtk_tree_view_append_column(treeview, column);
251 } else {
252 /* column for serial number */
253 renderer = gtk_cell_renderer_text_new();
254 //g_object_set(renderer, "editable", TRUE, NULL);
255 //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL);
256 column = gtk_tree_view_column_new_with_attributes("Serial Number",
257 renderer,
258 "text",
259 COLUMN_DEFAULT_SN,
260 NULL);
261 gtk_tree_view_append_column(treeview, column);
262
263 /* column for lens data */
264 renderer = gtk_cell_renderer_text_new();
265 //g_object_set(renderer, "editable", TRUE, NULL);
266 //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL);
267 column = gtk_tree_view_column_new_with_attributes("Lens data",
268 renderer,
269 "text",
270 COLUMN_DEFAULT_DATA,
271 NULL);
272 gtk_tree_view_append_column(treeview, column);
273
274 /* column for notes */
275 renderer = gtk_cell_renderer_text_new();
276 //g_object_set(renderer, "editable", TRUE, NULL);
277 //g_signal_connect(renderer, "edited", (GCallback) cell_edited_callback, NULL);
278 column = gtk_tree_view_column_new_with_attributes("Notes",
279 renderer,
280 "text",
281 COLUMN_DEFAULT_NOTES,
282 NULL);
283 gtk_tree_view_append_column(treeview, column);
284 }
285 }
286
287 static void on_row_activated (GtkTreeView* view,
288 GtkTreePath* path,
289 GtkTreeViewColumn* col,
290 gpointer userdata) {
291 GtkTreeIter iter;
292 GtkTreeModel *model;
293
294 model = gtk_tree_view_get_model(view);
295
296 if (gtk_tree_model_get_iter(model, &iter, path)) {
297 cur_iter = iter;
298 cur_view = view;
299 Row* row = row_new();
300
301 gtk_tree_model_get(model, &iter, COLUMN_DEFAULT_ID, &row->id, -1);
302 gtk_tree_model_get(model, &iter, COLUMN_DEFAULT_SN, &row->sn, -1);
303 gtk_tree_model_get(model, &iter, COLUMN_DEFAULT_DATA, &row->data, -1);
304 gtk_tree_model_get(model, &iter, COLUMN_DEFAULT_NOTES, &row->notes, -1);
305
306 //fprintf(stderr, "[id: %i, sn: %i, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
307 GtkWidget* input_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "input_dialog"));
308 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
309 gtk_entry_set_text(GTK_ENTRY(entry_sn), row->sn);
310
311 if (row->data != NULL) {
312 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
313 gtk_entry_set_text(GTK_ENTRY(entry_data), row->data);
314 }
315
316 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
317 gchar* id = g_strdup_printf("%ld", row->id);
318 gtk_entry_set_text(GTK_ENTRY(entry_id), id);
319 g_free(id);
320
321 if (row->notes != NULL) {
322 GtkWidget* textview_notes = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
323 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview_notes), GTK_WRAP_WORD);
324 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_notes));
325 gtk_text_buffer_set_text(buffer, row->notes, -1);
326 }
327
328 GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header"));
329 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
330 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
331 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
332 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
333 gchar* dialog_label = g_strconcat("Details [", label,"] Lens", NULL);
334 gtk_label_set_text(GTK_LABEL(header), dialog_label);
335 g_free(dialog_label);
336 GtkWidget* ok_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_ok"));
337 gtk_widget_hide(ok_btn);
338 GtkWidget* scan_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_scan"));
339 gtk_widget_hide(scan_btn);
340 GtkWidget* update_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_update"));
341 gtk_widget_show(update_btn);
342 GtkWidget* delete_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_delete"));
343 gtk_widget_show(delete_btn);
344
345 gtk_widget_show_all(input_dialog);
346
347 row_free(row, NULL);
348 }
349
350 }
351
352 static GtkWidget* add_tab() {
353 GtkListStore* store = NULL;
354 GtkWidget* treeview;
355 GtkWidget* scrolled_window;
356
357 store = gtk_list_store_new(4,
358 G_TYPE_STRING,
359 G_TYPE_STRING,
360 G_TYPE_STRING,
361 G_TYPE_INT64);
362 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
363 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_DEFAULT_DATA);
364 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_DEFAULT_SN);
365 g_signal_connect(treeview, "row-activated", G_CALLBACK(on_row_activated), NULL);
366 g_object_unref(store);
367 add_columns(GTK_TREE_VIEW(treeview), VIEWTYPE_DEFAULT);
368 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
369 g_object_set(scrolled_window, "vexpand", TRUE, NULL);
370 gtk_container_add(GTK_CONTAINER(scrolled_window), treeview);
371
372 return scrolled_window;
373 }
374
375 static void add_row(gint maker, Row* row) {
376 GtkListStore* store = NULL;
377 GtkWidget* treeview = NULL;
378 GtkTreeIter iter;
379
380 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
381 GtkWidget* scrolled_window = NULL;
382 Maker* maker_info = get_maker(maker);
383 //fprintf(stdout, "%lu - %s - %d\n", maker_info->id, maker_info->maker_name, maker_info->page);
384 if (maker_info->page >= 0)
385 scrolled_window = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), maker_info->page);
386 if (scrolled_window == NULL) {
387 /* new maker */
388 GtkWidget* tab_label = gtk_label_new(maker_info->maker_name);
389 scrolled_window = add_tab();
390 treeview = gtk_bin_get_child(GTK_BIN(scrolled_window));
391 maker_info->page = gtk_notebook_insert_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label, -1);
392 if (maker_info->page < 0) {
393 /* Huston whe have a problem */
394 gchar* err = g_strdup_printf("%s: Could not create tab\n", maker_info->maker_name);
395 fprintf(stderr, err);
396 show_message(GTK_MESSAGE_ERROR, err);
397 g_free(err);
398 } else {
399 update_maker(maker_info);
400 }
401 //fprintf(stdout, "%lu - %s - %d - %p\n", maker_info->id, maker_info->maker_name, maker_info->page, scrolled_window);
402 maker_free(maker_info);
403 } else {
404 treeview = gtk_bin_get_child(GTK_BIN(scrolled_window));
405 }
406
407 if (row) {
408 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)));
409 gtk_list_store_append(store, &iter);
410 gtk_list_store_set (store, &iter,
411 COLUMN_DEFAULT_SN, row->sn,
412 COLUMN_DEFAULT_DATA, row->data,
413 COLUMN_DEFAULT_NOTES, row->notes,
414 COLUMN_DEFAULT_ID, row->id,
415 -1);
416 }
417
418 gtk_widget_show_all(notebook);
419 }
420
421 static void create_search_result_dialog(GSList* rows) {
422 GtkListStore* store;
423 GtkWidget* treeview = NULL;
424 GtkTreeIter iter;
425
426 GtkWidget* dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_dialog"));
427 gtk_widget_set_size_request(dialog, 600, 300);
428 treeview = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_tree_view"));
429 store = gtk_list_store_new(5,
430 G_TYPE_STRING,
431 G_TYPE_STRING,
432 G_TYPE_STRING,
433 G_TYPE_STRING,
434 G_TYPE_INT64);
435 gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(store));
436 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_SEARCH_DATA);
437 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_SEARCH_SN);
438 //g_signal_connect(treeview, "row-activated", G_CALLBACK(on_row_activated), NULL);
439 g_object_unref(store);
440 add_columns(GTK_TREE_VIEW(treeview), VIEWTYPE_SEARCH);
441
442 for (GSList* elem = rows; elem; elem = elem->next) {
443 Row* row = elem->data;
444 gtk_list_store_append(store, &iter);
445 Maker* maker = get_maker(row->maker);
446 gtk_list_store_set (store, &iter,
447 COLUMN_SEARCH_MAKER, maker->maker_name,
448 COLUMN_SEARCH_SN, row->sn,
449 COLUMN_SEARCH_DATA, row->data,
450 COLUMN_SEARCH_NOTES, row->notes,
451 COLUMN_SEARCH_ID, row->id,
452 -1);
453 maker_free(maker);
454 }
455
456 gtk_widget_show_all(dialog);
457 }
458
459 static void initialize_notebook() {
460 GSList* ids = NULL;
461 GSList* rows = NULL;
462
463 GSList* makers = get_makers();
464 for (ids = makers; ids; ids = ids->next) {
465 gint id = get_maker_id(ids->data);
466 GSList* lenses = get_lens_by_maker(id);
467 if (lenses) {
468 for (rows = lenses; rows; rows = rows->next) {
469 Row* row = rows->data;
470 add_row(id, row);
471 }
472 g_slist_foreach(lenses, (GFunc)row_free, NULL);
473 g_slist_free(lenses);
474 lenses = NULL;
475 } else {
476 add_row(id, NULL);
477 }
478 }
479 g_slist_foreach(makers, (GFunc)g_free, NULL);
480 g_slist_free(makers);
481 }
482
483 G_MODULE_EXPORT void onDestroy(GtkWidget* self, gpointer data) {
484 clean(data);
485 }
486
487 G_MODULE_EXPORT void onQuit(GtkWidget* self, gpointer data) {
488 clean(data);
489 }
490
491 G_MODULE_EXPORT void about_show_button_press_event_cb(GtkWidget* self, gpointer data) {
492 GtkWidget* about_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "about_dialog"));
493 gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(about_dialog), get_logo());
494 gtk_widget_show_all(about_dialog);
495 gtk_dialog_run(GTK_DIALOG(about_dialog));
496 gtk_widget_hide(about_dialog);
497 }
498
499 G_MODULE_EXPORT void add_maker_clicked_cb(GtkWidget* self, gpointer data) {
500 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
501 GtkWidget* dialog = gtk_dialog_new_with_buttons("New Maker",
502 GTK_WINDOW(window),
503 GTK_DIALOG_DESTROY_WITH_PARENT,
504 "_Ok",
505 GTK_RESPONSE_ACCEPT,
506 "_Cancel",
507 GTK_RESPONSE_CANCEL,
508 NULL);
509 GtkWidget* content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog));
510 GtkWidget* maker_entry = gtk_entry_new();
511 gtk_container_add(GTK_CONTAINER(content_area), maker_entry);
512 gtk_widget_show_all (dialog);
513
514 gint res = gtk_dialog_run(GTK_DIALOG(dialog));
515
516 if (res == GTK_RESPONSE_ACCEPT) {
517 const gchar* maker = gtk_entry_get_text(GTK_ENTRY(maker_entry));
518 gchar* error = NULL;
519 gint id;
520
521 if ((id = add_maker(maker, &error)) != -1) {
522 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
523 GtkWidget* tab_label = gtk_label_new(maker);
524 GtkWidget* scrolled_window = add_tab();
525 gint page = gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
526 if (page < 0) {
527 // Huston whe have a problem
528 gchar* err = g_strdup_printf("%s: Could not create tab\n", maker);
529 fprintf(stderr, err);
530 show_message(GTK_MESSAGE_ERROR, err);
531 g_free(err);
532 } else {
533 //gint id = get_maker_id(maker);
534 Maker* maker_info = get_maker(id);
535 maker_info->page = page;
536 update_maker(maker_info);
537 gtk_widget_show_all(notebook);
538 }
539 } else {
540 // Huston whe have a problem
541 gchar* err = g_strdup_printf("%s: Could not add Maker '%s'\n", error, maker);
542 fprintf(stderr, err);
543 show_message(GTK_MESSAGE_ERROR, err);
544 g_free(err);
545 }
546 g_free(error);
547 }
548
549 gtk_widget_destroy(dialog);
550 }
551
552 G_MODULE_EXPORT void del_maker_clicked_cb(GtkWidget* self, gpointer data) {
553 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
554 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
555 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
556 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
557
558 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
559 GtkWidget* dialog = gtk_dialog_new_with_buttons("Delete Maker",
560 GTK_WINDOW(window),
561 GTK_DIALOG_DESTROY_WITH_PARENT,
562 "_Ok",
563 GTK_RESPONSE_ACCEPT,
564 "_Cancel",
565 GTK_RESPONSE_CANCEL,
566 NULL);
567 GtkWidget* content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog));
568 GtkWidget* maker_label = gtk_label_new(NULL);
569 gchar* warning = g_strdup_printf("<span foreground=\"red\" size=\"x-large\"><b>Remove [%s] and all lenses?</b></span>", label);
570 gtk_label_set_markup(GTK_LABEL(maker_label), warning);
571 g_free(warning);
572 gtk_container_add(GTK_CONTAINER(content_area), maker_label);
573 gtk_widget_show_all (dialog);
574
575 gint res = gtk_dialog_run(GTK_DIALOG(dialog));
576
577 if (res == GTK_RESPONSE_ACCEPT) {
578 gchar* error = NULL;
579
580 if (!delete_maker(label, &error)) {
581 notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
582 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), cur_page);
583 gtk_widget_show_all(notebook);
584 } else {
585 // Huston whe have a problem
586 gchar* err = g_strdup_printf("%s: Could not remove Maker '%s'\n", error, label);
587 fprintf(stderr, err);
588 show_message(GTK_MESSAGE_ERROR, err);
589 g_free(err);
590 }
591 g_free(error);
592 }
593
594 gtk_widget_destroy(dialog);
595 }
596
597
598 G_MODULE_EXPORT void add_lens_clicked_cb(GtkWidget* self, gpointer data) {
599 GtkWidget* input_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "input_dialog"));
600 GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header"));
601 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
602 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
603 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
604 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
605 gchar* dialog_label = g_strconcat("New [", label,"] Lens", NULL);
606 gtk_label_set_text(GTK_LABEL(header), dialog_label);
607 g_free(dialog_label);
608
609 GtkWidget* ok_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_ok"));
610 gtk_widget_show(ok_btn);
611 GtkWidget* scan_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_scan"));
612 gtk_widget_show(scan_btn);
613 GtkWidget* update_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_update"));
614 gtk_widget_hide(update_btn);
615 GtkWidget* delete_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_delete"));
616 gtk_widget_hide(delete_btn);
617
618 gtk_widget_show_all(input_dialog);
619 }
620
621 G_MODULE_EXPORT void find_lens_clicked_cb(GtkWidget* self, gpointer data) {
622 GtkWidget* search_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_dialog"));
623 gtk_widget_show_all(search_dialog);
624 }
625
626 G_MODULE_EXPORT void search_close_clicked_cb(GtkWidget* self, gpointer data) {
627 hide_search_dialog();
628 }
629
630 G_MODULE_EXPORT void search_ok_clicked_cb(GtkWidget* self, gpointer data) {
631 Row* row = row_new();
632 GtkWidget* entry_maker = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_maker"));
633 row->notes = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_maker)));
634
635 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_data"));
636 row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
637
638 GSList* rows = get_lens_by_search(row);
639 row_free(row, NULL);
640
641 create_search_result_dialog(rows);
642
643 g_slist_foreach(rows, (GFunc)row_free, NULL);
644 g_slist_free(rows);
645
646 hide_search_dialog();
647 }
648
649 G_MODULE_EXPORT gboolean on_textview_input_notes_focus_in_event(GtkWidget* self, GtkBuilder* data) {
650 GtkTextIter start, end;
651 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
652 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
653 gtk_text_buffer_get_bounds (buffer, &start, &end);
654 const gchar* buf = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
655 if (g_strcmp0(placeholder_str, buf) == 0)
656 gtk_text_buffer_set_text(buffer, "", -1);
657 return FALSE;
658 }
659
660 G_MODULE_EXPORT gboolean on_textview_input_notes_focus_out_event(GtkWidget* self, GtkBuilder* data) {
661 GtkTextIter start, end;
662 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
663 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
664 gtk_text_buffer_get_bounds (buffer, &start, &end);
665 const gchar* buf = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
666 if (g_strcmp0("", buf) == 0)
667 gtk_text_buffer_set_text(buffer, placeholder_str, -1);
668 return FALSE;
669 }
670
671 G_MODULE_EXPORT void input_close_clicked_cb(GtkWidget* self, GtkBuilder* data) {
672 hide_input_dialog();
673 }
674
675 G_MODULE_EXPORT void input_ok_clicked_cb(GtkWidget* self, gpointer data) {
676 Row* row = row_new();
677 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
678 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
679 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
680 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
681
682 row->maker = get_maker_id(label);
683
684 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
685 row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
686
687 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
688 row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
689
690 GtkTextIter start, end;
691 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
692 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
693 gtk_text_buffer_get_bounds (buffer, &start, &end);
694 row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
695
696 /* New lens */
697 if (add_lens(row)) {
698 gchar* err = g_strdup_printf("Add failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
699 fprintf(stderr, err);
700 show_message(GTK_MESSAGE_ERROR, err);
701 g_free(err);
702 } else {
703 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
704 gtk_entry_set_text(GTK_ENTRY(entry_id), g_strdup_printf("%lu", row->id));
705
706 add_row(get_maker_id(label), row);
707 }
708
709 row_free(row, NULL);
710 cur_view = NULL;
711
712 hide_input_dialog();
713 }
714
715 G_MODULE_EXPORT void input_scan_clicked_cb(GtkWidget* self, gpointer data) {
716 Row* row = row_new();
717 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
718 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
719 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
720 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
721
722 gchar* path = get_image_file();
723 if (path) {
724 Scanner_t* sc = scanner_create(path);
725
726 gchar* sn = get_lens_serial_number(sc);
727 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
728 gtk_entry_set_text(GTK_ENTRY(entry_sn), g_strdup(sn));
729 //row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
730 g_free(sn);
731
732 gchar* data = get_lens_info(sc);
733 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
734 gtk_entry_set_text(GTK_ENTRY(entry_data), g_strdup(data));
735 //row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
736 g_free(data);
737
738 gchar* lens_maker = get_lens_maker(sc);
739 //GtkTextIter start, end;
740 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
741 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
742 gtk_text_buffer_set_text(buffer, g_strdup_printf("Data Scanned from %s", path), -1);
743 //row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
744
745 scanner_destroy(sc);
746
747 /* New lens */
748 /*
749 * 1. Create maker if not exist
750 * 2. Change tab if maker is is not current tab
751 * 3. Update input_label to the current tab
752 */
753 GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header"));
754 Maker* maker = NULL;
755 gchar* dialog_label = NULL;
756
757 if (lens_maker) {
758 gint id;
759
760 if (label && g_ascii_strcasecmp(label, lens_maker) == 0) {
761 /* lens_maker same as than current maker */
762 } else {
763 id = get_maker_id(lens_maker);
764 if (id != -1) {
765 /* Change tab */
766 maker = get_maker(id);
767 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), maker->page);
768 dialog_label = g_strconcat("New [", maker->maker_name,"] Lens", NULL);
769 gtk_label_set_text(GTK_LABEL(header), dialog_label);
770 g_free(dialog_label);
771 } else {
772 /* Ask to add to current maker */
773 gchar* error = NULL;
774
775 id = add_maker(lens_maker, &error);
776 if (id != -1) {
777 add_row(id, NULL);
778 maker = get_maker(id);
779 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), maker->page);
780 dialog_label = g_strconcat("New [", maker->maker_name,"] Lens", NULL);
781 gtk_label_set_text(GTK_LABEL(header), dialog_label);
782 g_free(dialog_label);
783 }
784 g_free(error);
785 }
786 }
787 } else {
788 /* New lens for current maker */
789 }
790 maker_free(maker);
791 g_free(lens_maker);
792 }
793
794 g_free(path);
795 row_free(row, NULL);
796 }
797
798 G_MODULE_EXPORT void input_delete_clicked_cb(GtkWidget* self, gpointer data) {
799 Row* row = row_new();
800 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
801 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
802 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
803 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
804
805 row->maker = get_maker_id(label);
806
807 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
808 row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id)));
809 if (cur_view != NULL) {
810 if (delete_lens(row)) {
811 gchar* err = g_strdup_printf("Delete failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
812 fprintf(stderr, err);
813 show_message(GTK_MESSAGE_ERROR, err);
814 g_free(err);
815 }
816 GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view));
817 gtk_list_store_remove(store, &cur_iter);
818 }
819
820 row_free(row, NULL);
821 cur_view = NULL;
822
823 hide_input_dialog();
824 }
825
826 G_MODULE_EXPORT void input_update_clicked_cb(GtkWidget* self, gpointer data) {
827 Row* row = row_new();
828 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
829 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
830 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
831 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
832
833 row->maker = get_maker_id(label);
834
835 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
836 row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id)));
837
838 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
839 row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
840
841 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
842 row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
843
844 GtkTextIter start, end;
845 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
846 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
847 gtk_text_buffer_get_bounds (buffer, &start, &end);
848 row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
849
850 if (cur_view != NULL) {
851 if (update_lens(row)) {
852 gchar* err = g_strdup_printf("Update failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
853 fprintf(stderr, err);
854 show_message(GTK_MESSAGE_ERROR, err);
855 g_free(err);
856 }
857 GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view));
858 gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_SN, row->sn, -1);
859 gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_DATA, row->data, -1);
860 gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_NOTES, row->notes, -1);
861 }
862
863 row_free(row, NULL);
864 cur_view = NULL;
865
866 hide_input_dialog();
867 }
868
869 G_MODULE_EXPORT void search_result_ok_clicked_cb(GtkWidget* self, gpointer data) {
870 hide_search_result_dialog();
871 }
872
873 typedef enum {
874 FILE_SAVE_AS,
875 FILE_SAVE,
876 FILE_NEW,
877 FILE_OPEN
878 } FileAction;
879
880 static gchar* get_filename(FileAction fileAction, const gchar* title) {
881 GtkWidget *dialog;
882 GtkFileChooser *chooser;
883 GtkFileChooserAction action;
884 gint res;
885 GtkWidget* parent_window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
886 gchar* nameHint = NULL;
887 gchar* current_dir = NULL;
888
889 if (current_filename != NULL) {
890 current_dir = g_path_get_dirname(current_filename);
891 nameHint = g_path_get_basename(current_filename);
892 }
893 switch (fileAction) {
894 case FILE_SAVE_AS:
895 g_free(nameHint);
896 nameHint = g_strdup("Untitled document.csv");
897 action = GTK_FILE_CHOOSER_ACTION_SAVE;
898 break;
899 case FILE_SAVE:
900 if (nameHint == NULL)
901 nameHint = g_strdup("Untitled document.csv");
902 action = GTK_FILE_CHOOSER_ACTION_SAVE;
903 break;
904 case FILE_NEW:
905 g_free(nameHint);
906 nameHint = g_strdup("Untitled document.csv");
907 action = GTK_FILE_CHOOSER_ACTION_SAVE;
908 break;
909 case FILE_OPEN:
910 action = GTK_FILE_CHOOSER_ACTION_OPEN;
911 break;
912 }
913
914 if (FILE_OPEN == fileAction) {
915 dialog = gtk_file_chooser_dialog_new(title,
916 GTK_WINDOW(parent_window),
917 action,
918 ("_Cancel"),
919 GTK_RESPONSE_CANCEL,
920 ("_Open"),
921 GTK_RESPONSE_ACCEPT,
922 NULL);
923 } else {
924 dialog = gtk_file_chooser_dialog_new(title,
925 GTK_WINDOW(parent_window),
926 action,
927 ("_Cancel"),
928 GTK_RESPONSE_CANCEL,
929 ("_Save"),
930 GTK_RESPONSE_ACCEPT,
931 NULL);
932 }
933
934 chooser = GTK_FILE_CHOOSER(dialog);
935
936 GtkFileFilter* filter_csv = gtk_file_filter_new();
937 gtk_file_filter_add_mime_type(filter_csv, "text/csv");
938 gtk_file_filter_add_mime_type(filter_csv, "application/csv");
939 gtk_file_filter_add_mime_type(filter_csv, "application/x-csv");
940 gtk_file_filter_add_mime_type(filter_csv, "application/vnd.ms-excel");
941 gtk_file_filter_add_mime_type(filter_csv, "text/x-csv");
942 gtk_file_filter_add_mime_type(filter_csv, "text/comma-separated-values");
943 gtk_file_filter_add_mime_type(filter_csv, "text/x-comma-separated-values");
944 gtk_file_filter_add_mime_type(filter_csv, "text/tab-separated-values");
945 gtk_file_filter_add_pattern(filter_csv, "*.csv");
946 gtk_file_filter_set_name(filter_csv, "CSV files");
947 gtk_file_chooser_add_filter(chooser, filter_csv);
948 GtkFileFilter* filter_plain = gtk_file_filter_new();
949 gtk_file_filter_add_mime_type(filter_plain, "text/plain");
950 gtk_file_filter_set_name(filter_plain, "Plain text");
951 gtk_file_chooser_add_filter(chooser, filter_plain);
952
953 if (FILE_OPEN != fileAction) {
954 gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
955 GtkFileFilter* filter_all = gtk_file_filter_new();
956 gtk_file_filter_add_pattern(filter_all, "*");
957 gtk_file_filter_set_name(filter_all, "All files");
958 gtk_file_chooser_add_filter(chooser, filter_all);
959 gtk_file_chooser_set_current_name(chooser, nameHint);
960 }
961
962 if (current_dir != NULL)
963 gtk_file_chooser_set_current_folder(chooser, current_dir);
964
965 res = gtk_dialog_run(GTK_DIALOG(dialog));
966 if (res == GTK_RESPONSE_ACCEPT) {
967 g_free(current_filename);
968 current_filename = gtk_file_chooser_get_filename(chooser);
969 }
970
971 gtk_widget_destroy (dialog);
972 g_free(nameHint);
973 g_free(current_dir);
974
975 return res == GTK_RESPONSE_ACCEPT ? g_strdup(current_filename) : NULL;
976 }
977
978 void commit(const gchar* filename) {
979 CvsError* err = NULL;
980
981 if (filename) {
982 Instructions instructions = {
983 .file = filename,
984 .write = true,
985 .overwrite = true,
986 .first_line_header = true
987 };
988 CsvParser* parser = csv_parser_new(&instructions, &err);
989 if (parser) {
990 dump_storage(parser);
991 csv_parser_free(parser);
992 } else {
993 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
994 csv_error_clear(&err);
995 }
996 }
997 }
998
999 G_MODULE_EXPORT void onSaveAs(GtkWidget* self, gpointer data) {
1000 gchar* filename = get_filename(FILE_NEW, "New File");
1001 commit(filename);
1002 g_free(filename);
1003 }
1004
1005 G_MODULE_EXPORT void onOpen(GtkWidget* self, gpointer data) {
1006 CvsError* err = NULL;
1007 gchar* cvsErr = NULL;
1008 bool replace = false;
1009 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
1010
1011 gchar* filename = get_filename(FILE_OPEN, "Open File");
1012 if (filename) {
1013 Instructions instructions = {
1014 .file = filename,
1015 .first_line_header = true,
1016 .write = false,
1017 .overwrite = false
1018 };
1019 CsvParser* parser = csv_parser_new(&instructions, &err);
1020 if (!parser) {
1021 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
1022 csv_error_clear(&err);
1023 } else {
1024 if ((replace = show_message(GTK_MESSAGE_QUESTION, "Should file content replace current?")) == true) {
1025 for (gint i = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook)); i > 0; i--) {
1026 GtkWidget* window = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), i-1);
1027 GtkWidget* treeview = gtk_bin_get_child(GTK_BIN(window));
1028 GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
1029 GtkListStore* store = GTK_LIST_STORE(model);
1030 gtk_list_store_clear(store);
1031 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), i-1);
1032 }
1033 GSList* makers = get_makers();
1034 for (GSList* elem = makers; elem; elem = elem->next) {
1035 Maker* maker = get_maker(get_maker_id(elem->data));
1036 delete_maker(maker->maker_name, &cvsErr);
1037 maker_free(maker);
1038 }
1039 g_slist_foreach(makers, (GFunc)g_free, NULL);
1040 g_slist_free(makers);
1041 }
1042 Record* r = NULL;
1043 while ((r = csv_parser_next_line(parser, &err)) != NULL) {
1044 if (err) {
1045 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
1046 csv_error_clear(&err);
1047 }
1048 gint id;
1049 if ((id = get_maker_id(r->maker)) == -1) {
1050 id = add_maker(r->maker, &cvsErr);
1051 }
1052 Row* row = row_new();
1053 row->maker = id;
1054 row->sn = g_strdup(r->sn);
1055 row->data = g_strdup(r->data);
1056 row->notes = g_strdup(r->notes);
1057 csv_record_free(r);
1058 add_lens(row);
1059 add_row(row->maker, row);
1060 row_free(row, NULL);
1061 }
1062 csv_parser_free(parser);
1063 if (replace)
1064 initialize_notebook();
1065 }
1066 g_free(filename);
1067 }
1068 }
1069
1070 G_MODULE_EXPORT void onNew(GtkWidget* self, gpointer data) {
1071 gchar* filename = get_filename(FILE_NEW, "New File");
1072 commit(filename);
1073 g_free(filename);
1074 }
1075
1076 G_MODULE_EXPORT void onSave(GtkWidget* self, gpointer data) {
1077 gchar* filename = get_filename(FILE_SAVE, "Save File");
1078 commit(filename);
1079 g_free(filename);
1080 }
1081
1082 gboolean init_gui() {
1083 gboolean fail = TRUE;
1084
1085 builder = gtk_builder_new_from_string(lensdatabase_ui, lensdatabase_ui_len);
1086
1087 if (builder != NULL) {
1088 fail = FALSE;
1089 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
1090
1091 GtkWidget* add_maker = GTK_WIDGET(gtk_builder_get_object(builder, "add_maker"));
1092 GtkWidget* add_image = gtk_image_new_from_pixbuf(get_btn_image_maker_new());
1093 gtk_button_set_image(GTK_BUTTON(add_maker), add_image);
1094
1095 GtkWidget* del_maker = GTK_WIDGET(gtk_builder_get_object(builder, "del_maker"));
1096 GtkWidget* del_image = gtk_image_new_from_pixbuf(get_btn_maker_remove_image());
1097 gtk_button_set_image(GTK_BUTTON(del_maker), del_image);
1098
1099 GtkWidget* about_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "about_dialog"));
1100 gtk_window_set_transient_for(GTK_WINDOW(about_dialog), GTK_WINDOW(window));
1101 gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(about_dialog), COMMENT);
1102 gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(about_dialog), PACKAGE_NAME);
1103 gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about_dialog), VERSION);
1104
1105 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
1106 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
1107 gtk_text_buffer_set_text(buffer, placeholder_str, -1);
1108
1109 gtk_builder_connect_signals(builder, builder);
1110
1111 initialize_notebook();
1112
1113 gtk_widget_show(window);
1114
1115 gtk_main();
1116 }
1117
1118 return fail;
1119 }
This page took 1.078978 seconds and 6 git commands to generate.