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