]> git.datanom.net - lensdb.git/blob - src/gui.c
Add feature to move lens to other Maker
[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 GtkWidget* move_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_move"));
345 gtk_widget_show(move_btn);
346
347 gtk_widget_show_all(input_dialog);
348
349 row_free(row, NULL);
350 }
351
352 }
353
354 static GtkWidget* add_tab() {
355 GtkListStore* store = NULL;
356 GtkWidget* treeview;
357 GtkWidget* scrolled_window;
358
359 store = gtk_list_store_new(4,
360 G_TYPE_STRING,
361 G_TYPE_STRING,
362 G_TYPE_STRING,
363 G_TYPE_INT64);
364 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
365 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_DEFAULT_DATA);
366 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_DEFAULT_SN);
367 g_signal_connect(treeview, "row-activated", G_CALLBACK(on_row_activated), NULL);
368 g_object_unref(store);
369 add_columns(GTK_TREE_VIEW(treeview), VIEWTYPE_DEFAULT);
370 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
371 g_object_set(scrolled_window, "vexpand", TRUE, NULL);
372 gtk_container_add(GTK_CONTAINER(scrolled_window), treeview);
373
374 return scrolled_window;
375 }
376
377 static void add_row(gint maker, Row* row) {
378 GtkListStore* store = NULL;
379 GtkWidget* treeview = NULL;
380 GtkTreeIter iter;
381
382 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
383 GtkWidget* scrolled_window = NULL;
384 Maker* maker_info = get_maker(maker);
385 //fprintf(stdout, "%lu - %s - %d\n", maker_info->id, maker_info->maker_name, maker_info->page);
386 if (maker_info->page >= 0)
387 scrolled_window = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), maker_info->page);
388 if (scrolled_window == NULL) {
389 /* new maker */
390 GtkWidget* tab_label = gtk_label_new(maker_info->maker_name);
391 scrolled_window = add_tab();
392 treeview = gtk_bin_get_child(GTK_BIN(scrolled_window));
393 maker_info->page = gtk_notebook_insert_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label, -1);
394 if (maker_info->page < 0) {
395 /* Huston whe have a problem */
396 gchar* err = g_strdup_printf("%s: Could not create tab\n", maker_info->maker_name);
397 fprintf(stderr, err);
398 show_message(GTK_MESSAGE_ERROR, err);
399 g_free(err);
400 } else {
401 update_maker(maker_info);
402 }
403 //fprintf(stdout, "%lu - %s - %d - %p\n", maker_info->id, maker_info->maker_name, maker_info->page, scrolled_window);
404 maker_free(maker_info);
405 } else {
406 treeview = gtk_bin_get_child(GTK_BIN(scrolled_window));
407 }
408
409 if (row) {
410 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)));
411 gtk_list_store_append(store, &iter);
412 gtk_list_store_set (store, &iter,
413 COLUMN_DEFAULT_SN, row->sn,
414 COLUMN_DEFAULT_DATA, row->data,
415 COLUMN_DEFAULT_NOTES, row->notes,
416 COLUMN_DEFAULT_ID, row->id,
417 -1);
418 }
419
420 gtk_widget_show_all(notebook);
421 }
422
423 static void create_search_result_dialog(GSList* rows) {
424 GtkListStore* store;
425 GtkWidget* treeview = NULL;
426 GtkTreeIter iter;
427
428 GtkWidget* dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_dialog"));
429 gtk_widget_set_size_request(dialog, 600, 300);
430 treeview = GTK_WIDGET(gtk_builder_get_object(builder, "search_result_tree_view"));
431 store = gtk_list_store_new(5,
432 G_TYPE_STRING,
433 G_TYPE_STRING,
434 G_TYPE_STRING,
435 G_TYPE_STRING,
436 G_TYPE_INT64);
437 gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(store));
438 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_SEARCH_DATA);
439 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COLUMN_SEARCH_SN);
440 //g_signal_connect(treeview, "row-activated", G_CALLBACK(on_row_activated), NULL);
441 g_object_unref(store);
442 add_columns(GTK_TREE_VIEW(treeview), VIEWTYPE_SEARCH);
443
444 for (GSList* elem = rows; elem; elem = elem->next) {
445 Row* row = elem->data;
446 gtk_list_store_append(store, &iter);
447 Maker* maker = get_maker(row->maker);
448 gtk_list_store_set (store, &iter,
449 COLUMN_SEARCH_MAKER, maker->maker_name,
450 COLUMN_SEARCH_SN, row->sn,
451 COLUMN_SEARCH_DATA, row->data,
452 COLUMN_SEARCH_NOTES, row->notes,
453 COLUMN_SEARCH_ID, row->id,
454 -1);
455 maker_free(maker);
456 }
457
458 gtk_widget_show_all(dialog);
459 }
460
461 static void initialize_notebook() {
462 GSList* ids = NULL;
463 GSList* rows = NULL;
464
465 GSList* makers = get_makers();
466 for (ids = makers; ids; ids = ids->next) {
467 gint id = get_maker_id(ids->data);
468 GSList* lenses = get_lens_by_maker(id);
469 if (lenses) {
470 for (rows = lenses; rows; rows = rows->next) {
471 Row* row = rows->data;
472 add_row(id, row);
473 }
474 g_slist_foreach(lenses, (GFunc)row_free, NULL);
475 g_slist_free(lenses);
476 lenses = NULL;
477 } else {
478 add_row(id, NULL);
479 }
480 }
481 g_slist_foreach(makers, (GFunc)g_free, NULL);
482 g_slist_free(makers);
483 }
484
485 G_MODULE_EXPORT void onDestroy(GtkWidget* self, gpointer data) {
486 clean(data);
487 }
488
489 G_MODULE_EXPORT void onQuit(GtkWidget* self, gpointer data) {
490 clean(data);
491 }
492
493 G_MODULE_EXPORT void about_show_button_press_event_cb(GtkWidget* self, gpointer data) {
494 GtkWidget* about_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "about_dialog"));
495 gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(about_dialog), get_logo());
496 gtk_widget_show_all(about_dialog);
497 gtk_dialog_run(GTK_DIALOG(about_dialog));
498 gtk_widget_hide(about_dialog);
499 }
500
501 G_MODULE_EXPORT void add_maker_clicked_cb(GtkWidget* self, gpointer data) {
502 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
503 GtkWidget* dialog = gtk_dialog_new_with_buttons("New Maker",
504 GTK_WINDOW(window),
505 GTK_DIALOG_DESTROY_WITH_PARENT,
506 "_Ok",
507 GTK_RESPONSE_ACCEPT,
508 "_Cancel",
509 GTK_RESPONSE_CANCEL,
510 NULL);
511 GtkWidget* content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog));
512 GtkWidget* maker_entry = gtk_entry_new();
513 gtk_container_add(GTK_CONTAINER(content_area), maker_entry);
514 gtk_widget_show_all (dialog);
515
516 gint res = gtk_dialog_run(GTK_DIALOG(dialog));
517
518 if (res == GTK_RESPONSE_ACCEPT) {
519 const gchar* maker = gtk_entry_get_text(GTK_ENTRY(maker_entry));
520 gchar* error = NULL;
521 gint id;
522
523 if ((id = add_maker(maker, &error)) != -1) {
524 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
525 GtkWidget* tab_label = gtk_label_new(maker);
526 GtkWidget* scrolled_window = add_tab();
527 gint page = gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
528 if (page < 0) {
529 // Huston whe have a problem
530 gchar* err = g_strdup_printf("%s: Could not create tab\n", maker);
531 fprintf(stderr, err);
532 show_message(GTK_MESSAGE_ERROR, err);
533 g_free(err);
534 } else {
535 //gint id = get_maker_id(maker);
536 Maker* maker_info = get_maker(id);
537 maker_info->page = page;
538 update_maker(maker_info);
539 gtk_widget_show_all(notebook);
540 }
541 } else {
542 // Huston whe have a problem
543 gchar* err = g_strdup_printf("%s: Could not add Maker '%s'\n", error, maker);
544 fprintf(stderr, err);
545 show_message(GTK_MESSAGE_ERROR, err);
546 g_free(err);
547 }
548 g_free(error);
549 }
550
551 gtk_widget_destroy(dialog);
552 }
553
554 G_MODULE_EXPORT void del_maker_clicked_cb(GtkWidget* self, gpointer data) {
555 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
556 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
557 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
558 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
559
560 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
561 GtkWidget* dialog = gtk_dialog_new_with_buttons("Delete Maker",
562 GTK_WINDOW(window),
563 GTK_DIALOG_DESTROY_WITH_PARENT,
564 "_Ok",
565 GTK_RESPONSE_ACCEPT,
566 "_Cancel",
567 GTK_RESPONSE_CANCEL,
568 NULL);
569 GtkWidget* content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog));
570 GtkWidget* maker_label = gtk_label_new(NULL);
571 gchar* warning = g_strdup_printf("<span foreground=\"red\" size=\"x-large\"><b>Remove [%s] and all lenses?</b></span>", label);
572 gtk_label_set_markup(GTK_LABEL(maker_label), warning);
573 g_free(warning);
574 gtk_container_add(GTK_CONTAINER(content_area), maker_label);
575 gtk_widget_show_all (dialog);
576
577 gint res = gtk_dialog_run(GTK_DIALOG(dialog));
578
579 if (res == GTK_RESPONSE_ACCEPT) {
580 gchar* error = NULL;
581
582 if (!delete_maker(label, &error)) {
583 notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
584 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), cur_page);
585 gtk_widget_show_all(notebook);
586 } else {
587 // Huston whe have a problem
588 gchar* err = g_strdup_printf("%s: Could not remove Maker '%s'\n", error, label);
589 fprintf(stderr, err);
590 show_message(GTK_MESSAGE_ERROR, err);
591 g_free(err);
592 }
593 g_free(error);
594 }
595
596 gtk_widget_destroy(dialog);
597 }
598
599
600 G_MODULE_EXPORT void add_lens_clicked_cb(GtkWidget* self, gpointer data) {
601 GtkWidget* input_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "input_dialog"));
602 GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header"));
603 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
604 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
605 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
606 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
607 gchar* dialog_label = g_strconcat("New [", label,"] Lens", NULL);
608 gtk_label_set_text(GTK_LABEL(header), dialog_label);
609 g_free(dialog_label);
610
611 GtkWidget* ok_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_ok"));
612 gtk_widget_show(ok_btn);
613 GtkWidget* scan_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_scan"));
614 gtk_widget_show(scan_btn);
615 GtkWidget* update_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_update"));
616 gtk_widget_hide(update_btn);
617 GtkWidget* delete_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_delete"));
618 gtk_widget_hide(delete_btn);
619 GtkWidget* move_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_move"));
620 gtk_widget_hide(move_btn);
621
622 gtk_widget_show_all(input_dialog);
623 }
624
625 G_MODULE_EXPORT void find_lens_clicked_cb(GtkWidget* self, gpointer data) {
626 GtkWidget* search_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "search_dialog"));
627 gtk_widget_show_all(search_dialog);
628 }
629
630 G_MODULE_EXPORT void search_close_clicked_cb(GtkWidget* self, gpointer data) {
631 hide_search_dialog();
632 }
633
634 G_MODULE_EXPORT void search_ok_clicked_cb(GtkWidget* self, gpointer data) {
635 Row* row = row_new();
636 GtkWidget* entry_maker = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_maker"));
637 row->notes = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_maker)));
638
639 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_search_data"));
640 row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
641
642 GSList* rows = get_lens_by_search(row);
643 row_free(row, NULL);
644
645 create_search_result_dialog(rows);
646
647 g_slist_foreach(rows, (GFunc)row_free, NULL);
648 g_slist_free(rows);
649
650 hide_search_dialog();
651 }
652
653 G_MODULE_EXPORT gboolean on_textview_input_notes_focus_in_event(GtkWidget* self, GtkBuilder* data) {
654 GtkTextIter start, end;
655 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
656 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
657 gtk_text_buffer_get_bounds (buffer, &start, &end);
658 const gchar* buf = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
659 if (g_strcmp0(placeholder_str, buf) == 0)
660 gtk_text_buffer_set_text(buffer, "", -1);
661 return FALSE;
662 }
663
664 G_MODULE_EXPORT gboolean on_textview_input_notes_focus_out_event(GtkWidget* self, GtkBuilder* data) {
665 GtkTextIter start, end;
666 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
667 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
668 gtk_text_buffer_get_bounds (buffer, &start, &end);
669 const gchar* buf = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
670 if (g_strcmp0("", buf) == 0)
671 gtk_text_buffer_set_text(buffer, placeholder_str, -1);
672 return FALSE;
673 }
674
675 G_MODULE_EXPORT void input_close_clicked_cb(GtkWidget* self, GtkBuilder* data) {
676 hide_input_dialog();
677 }
678
679 G_MODULE_EXPORT void input_ok_clicked_cb(GtkWidget* self, gpointer data) {
680 Row* row = row_new();
681 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
682 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
683 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
684 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
685
686 row->maker = get_maker_id(label);
687
688 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
689 row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
690
691 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
692 row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
693
694 GtkTextIter start, end;
695 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
696 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
697 gtk_text_buffer_get_bounds (buffer, &start, &end);
698 row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
699
700 /* New lens */
701 if (add_lens(row)) {
702 gchar* err = g_strdup_printf("Add failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
703 fprintf(stderr, err);
704 show_message(GTK_MESSAGE_ERROR, err);
705 g_free(err);
706 } else {
707 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
708 gtk_entry_set_text(GTK_ENTRY(entry_id), g_strdup_printf("%lu", row->id));
709
710 add_row(get_maker_id(label), row);
711 }
712
713 row_free(row, NULL);
714 cur_view = NULL;
715
716 hide_input_dialog();
717 }
718
719 G_MODULE_EXPORT void input_scan_clicked_cb(GtkWidget* self, gpointer data) {
720 Row* row = row_new();
721 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
722 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
723 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
724 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
725
726 gchar* path = get_image_file();
727 if (path) {
728 Scanner_t* sc = scanner_create(path);
729
730 gchar* sn = get_lens_serial_number(sc);
731 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
732 gtk_entry_set_text(GTK_ENTRY(entry_sn), g_strdup(sn));
733 //row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
734 g_free(sn);
735
736 gchar* data = get_lens_info(sc);
737 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
738 gtk_entry_set_text(GTK_ENTRY(entry_data), g_strdup(data));
739 //row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
740 g_free(data);
741
742 gchar* lens_maker = get_lens_maker(sc);
743 //GtkTextIter start, end;
744 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
745 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
746 gtk_text_buffer_set_text(buffer, g_strdup_printf("Data Scanned from %s", path), -1);
747 //row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
748
749 scanner_destroy(sc);
750
751 /* New lens */
752 /*
753 * 1. Create maker if not exist
754 * 2. Change tab if maker is is not current tab
755 * 3. Update input_label to the current tab
756 */
757 GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header"));
758 Maker* maker = NULL;
759 gchar* dialog_label = NULL;
760
761 if (lens_maker) {
762 gint id;
763
764 if (label && g_ascii_strcasecmp(label, lens_maker) == 0) {
765 /* lens_maker same as than current maker */
766 } else {
767 id = get_maker_id(lens_maker);
768 if (id != -1) {
769 /* Change tab */
770 maker = get_maker(id);
771 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), maker->page);
772 dialog_label = g_strconcat("New [", maker->maker_name,"] Lens", NULL);
773 gtk_label_set_text(GTK_LABEL(header), dialog_label);
774 g_free(dialog_label);
775 } else {
776 /* Ask to add to current maker */
777 gchar* error = NULL;
778
779 id = add_maker(lens_maker, &error);
780 if (id != -1) {
781 add_row(id, NULL);
782 maker = get_maker(id);
783 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), maker->page);
784 dialog_label = g_strconcat("New [", maker->maker_name,"] Lens", NULL);
785 gtk_label_set_text(GTK_LABEL(header), dialog_label);
786 g_free(dialog_label);
787 }
788 g_free(error);
789 }
790 }
791 } else {
792 /* New lens for current maker */
793 }
794 maker_free(maker);
795 g_free(lens_maker);
796 }
797
798 g_free(path);
799 row_free(row, NULL);
800 }
801
802 G_MODULE_EXPORT void input_delete_clicked_cb(GtkWidget* self, gpointer data) {
803 Row* row = row_new();
804 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
805 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
806 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
807 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
808
809 row->maker = get_maker_id(label);
810
811 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
812 row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id)));
813 if (cur_view != NULL) {
814 if (delete_lens(row)) {
815 gchar* err = g_strdup_printf("Delete failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
816 fprintf(stderr, err);
817 show_message(GTK_MESSAGE_ERROR, err);
818 g_free(err);
819 }
820 GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view));
821 gtk_list_store_remove(store, &cur_iter);
822 }
823
824 row_free(row, NULL);
825 cur_view = NULL;
826
827 hide_input_dialog();
828 }
829
830 G_MODULE_EXPORT void input_update_clicked_cb(GtkWidget* self, gpointer data) {
831 Row* row = row_new();
832 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
833 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
834 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
835 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
836
837 row->maker = get_maker_id(label);
838
839 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
840 row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id)));
841
842 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
843 row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
844
845 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
846 row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
847
848 GtkTextIter start, end;
849 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
850 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
851 gtk_text_buffer_get_bounds (buffer, &start, &end);
852 row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
853
854 if (cur_view != NULL) {
855 if (update_lens(row)) {
856 gchar* err = g_strdup_printf("Update failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
857 fprintf(stderr, err);
858 show_message(GTK_MESSAGE_ERROR, err);
859 g_free(err);
860 }
861 GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view));
862 gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_SN, row->sn, -1);
863 gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_DATA, row->data, -1);
864 gtk_list_store_set(store, &cur_iter, COLUMN_DEFAULT_NOTES, row->notes, -1);
865 }
866
867 row_free(row, NULL);
868 cur_view = NULL;
869
870 hide_input_dialog();
871 }
872
873 G_MODULE_EXPORT void input_move_clicked_cb(GtkWidget* self, gpointer data) {
874 GtkWidget *dialog, *content_area, *combo;
875
876 GtkWidget* parent = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
877 GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
878 dialog = gtk_dialog_new_with_buttons("New Maker",
879 GTK_WINDOW(parent),
880 flags,
881 "_OK",
882 GTK_RESPONSE_ACCEPT,
883 "_Cancel",
884 GTK_RESPONSE_REJECT,
885 NULL);
886
887 content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
888 combo = gtk_combo_box_text_new();
889 GSList* makers = get_makers();
890
891 for (GSList* elem = makers; elem; elem = elem->next) {
892 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), g_strdup((const gchar*)elem->data));
893 }
894 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
895 gtk_widget_show_all(combo);
896
897 g_slist_foreach(makers, (GFunc)g_free, NULL);
898 g_slist_free(makers);
899
900 gtk_container_add(GTK_CONTAINER(content_area), combo);
901
902 gint response = gtk_dialog_run(GTK_DIALOG(dialog));
903 if (response == GTK_RESPONSE_ACCEPT) {
904 Row* row = row_new();
905
906 gchar* maker = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
907 row->maker = get_maker_id(maker);
908 g_free(maker);
909
910 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
911 row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id)));
912
913 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
914 row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
915
916 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
917 row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
918
919 GtkTextIter start, end;
920 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
921 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
922 gtk_text_buffer_get_bounds (buffer, &start, &end);
923 row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
924
925 if (cur_view != NULL) {
926 if (update_lens_maker(row)) {
927 gchar* err = g_strdup_printf("Update failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
928 fprintf(stderr, err);
929 show_message(GTK_MESSAGE_ERROR, err);
930 g_free(err);
931 }
932 GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view));
933 gtk_list_store_remove(store, &cur_iter);
934 add_row(row->maker, row);
935 }
936
937 row_free(row, NULL);
938 cur_view = NULL;
939 }
940 gtk_widget_destroy(dialog);
941
942 hide_input_dialog();
943 }
944
945 G_MODULE_EXPORT void search_result_ok_clicked_cb(GtkWidget* self, gpointer data) {
946 hide_search_result_dialog();
947 }
948
949 typedef enum {
950 FILE_SAVE_AS,
951 FILE_SAVE,
952 FILE_NEW,
953 FILE_OPEN
954 } FileAction;
955
956 static gchar* get_filename(FileAction fileAction, const gchar* title) {
957 GtkWidget *dialog;
958 GtkFileChooser *chooser;
959 GtkFileChooserAction action;
960 gint res;
961 GtkWidget* parent_window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
962 gchar* nameHint = NULL;
963 gchar* current_dir = NULL;
964
965 if (current_filename != NULL) {
966 current_dir = g_path_get_dirname(current_filename);
967 nameHint = g_path_get_basename(current_filename);
968 }
969 switch (fileAction) {
970 case FILE_SAVE_AS:
971 g_free(nameHint);
972 nameHint = g_strdup("Untitled document.csv");
973 action = GTK_FILE_CHOOSER_ACTION_SAVE;
974 break;
975 case FILE_SAVE:
976 if (nameHint == NULL)
977 nameHint = g_strdup("Untitled document.csv");
978 action = GTK_FILE_CHOOSER_ACTION_SAVE;
979 break;
980 case FILE_NEW:
981 g_free(nameHint);
982 nameHint = g_strdup("Untitled document.csv");
983 action = GTK_FILE_CHOOSER_ACTION_SAVE;
984 break;
985 case FILE_OPEN:
986 action = GTK_FILE_CHOOSER_ACTION_OPEN;
987 break;
988 }
989
990 if (FILE_OPEN == fileAction) {
991 dialog = gtk_file_chooser_dialog_new(title,
992 GTK_WINDOW(parent_window),
993 action,
994 ("_Cancel"),
995 GTK_RESPONSE_CANCEL,
996 ("_Open"),
997 GTK_RESPONSE_ACCEPT,
998 NULL);
999 } else {
1000 dialog = gtk_file_chooser_dialog_new(title,
1001 GTK_WINDOW(parent_window),
1002 action,
1003 ("_Cancel"),
1004 GTK_RESPONSE_CANCEL,
1005 ("_Save"),
1006 GTK_RESPONSE_ACCEPT,
1007 NULL);
1008 }
1009
1010 chooser = GTK_FILE_CHOOSER(dialog);
1011
1012 GtkFileFilter* filter_csv = gtk_file_filter_new();
1013 gtk_file_filter_add_mime_type(filter_csv, "text/csv");
1014 gtk_file_filter_add_mime_type(filter_csv, "application/csv");
1015 gtk_file_filter_add_mime_type(filter_csv, "application/x-csv");
1016 gtk_file_filter_add_mime_type(filter_csv, "application/vnd.ms-excel");
1017 gtk_file_filter_add_mime_type(filter_csv, "text/x-csv");
1018 gtk_file_filter_add_mime_type(filter_csv, "text/comma-separated-values");
1019 gtk_file_filter_add_mime_type(filter_csv, "text/x-comma-separated-values");
1020 gtk_file_filter_add_mime_type(filter_csv, "text/tab-separated-values");
1021 gtk_file_filter_add_pattern(filter_csv, "*.csv");
1022 gtk_file_filter_set_name(filter_csv, "CSV files");
1023 gtk_file_chooser_add_filter(chooser, filter_csv);
1024 GtkFileFilter* filter_plain = gtk_file_filter_new();
1025 gtk_file_filter_add_mime_type(filter_plain, "text/plain");
1026 gtk_file_filter_set_name(filter_plain, "Plain text");
1027 gtk_file_chooser_add_filter(chooser, filter_plain);
1028
1029 if (FILE_OPEN != fileAction) {
1030 gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
1031 GtkFileFilter* filter_all = gtk_file_filter_new();
1032 gtk_file_filter_add_pattern(filter_all, "*");
1033 gtk_file_filter_set_name(filter_all, "All files");
1034 gtk_file_chooser_add_filter(chooser, filter_all);
1035 gtk_file_chooser_set_current_name(chooser, nameHint);
1036 }
1037
1038 if (current_dir != NULL)
1039 gtk_file_chooser_set_current_folder(chooser, current_dir);
1040
1041 res = gtk_dialog_run(GTK_DIALOG(dialog));
1042 if (res == GTK_RESPONSE_ACCEPT) {
1043 g_free(current_filename);
1044 current_filename = gtk_file_chooser_get_filename(chooser);
1045 }
1046
1047 gtk_widget_destroy (dialog);
1048 g_free(nameHint);
1049 g_free(current_dir);
1050
1051 return res == GTK_RESPONSE_ACCEPT ? g_strdup(current_filename) : NULL;
1052 }
1053
1054 void commit(const gchar* filename) {
1055 CvsError* err = NULL;
1056
1057 if (filename) {
1058 Instructions instructions = {
1059 .file = filename,
1060 .write = true,
1061 .overwrite = true,
1062 .first_line_header = true
1063 };
1064 CsvParser* parser = csv_parser_new(&instructions, &err);
1065 if (parser) {
1066 dump_storage(parser);
1067 csv_parser_free(parser);
1068 } else {
1069 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
1070 csv_error_clear(&err);
1071 }
1072 }
1073 }
1074
1075 G_MODULE_EXPORT void onSaveAs(GtkWidget* self, gpointer data) {
1076 gchar* filename = get_filename(FILE_NEW, "New File");
1077 commit(filename);
1078 g_free(filename);
1079 }
1080
1081 G_MODULE_EXPORT void onOpen(GtkWidget* self, gpointer data) {
1082 CvsError* err = NULL;
1083 gchar* cvsErr = NULL;
1084 bool replace = false;
1085 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
1086
1087 gchar* filename = get_filename(FILE_OPEN, "Open File");
1088 if (filename) {
1089 Instructions instructions = {
1090 .file = filename,
1091 .first_line_header = true,
1092 .write = false,
1093 .overwrite = false
1094 };
1095 CsvParser* parser = csv_parser_new(&instructions, &err);
1096 if (!parser) {
1097 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
1098 csv_error_clear(&err);
1099 } else {
1100 if ((replace = show_message(GTK_MESSAGE_QUESTION, "Should file content replace current?")) == true) {
1101 for (gint i = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook)); i > 0; i--) {
1102 GtkWidget* window = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), i-1);
1103 GtkWidget* treeview = gtk_bin_get_child(GTK_BIN(window));
1104 GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
1105 GtkListStore* store = GTK_LIST_STORE(model);
1106 gtk_list_store_clear(store);
1107 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), i-1);
1108 }
1109 GSList* makers = get_makers();
1110 for (GSList* elem = makers; elem; elem = elem->next) {
1111 Maker* maker = get_maker(get_maker_id(elem->data));
1112 delete_maker(maker->maker_name, &cvsErr);
1113 maker_free(maker);
1114 }
1115 g_slist_foreach(makers, (GFunc)g_free, NULL);
1116 g_slist_free(makers);
1117 }
1118 Record* r = NULL;
1119 while ((r = csv_parser_next_line(parser, &err)) != NULL) {
1120 if (err) {
1121 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
1122 csv_error_clear(&err);
1123 }
1124 gint id;
1125 if ((id = get_maker_id(r->maker)) == -1) {
1126 id = add_maker(r->maker, &cvsErr);
1127 }
1128 Row* row = row_new();
1129 row->maker = id;
1130 row->sn = g_strdup(r->sn);
1131 row->data = g_strdup(r->data);
1132 row->notes = g_strdup(r->notes);
1133 csv_record_free(r);
1134 add_lens(row);
1135 add_row(row->maker, row);
1136 row_free(row, NULL);
1137 }
1138 csv_parser_free(parser);
1139 if (replace)
1140 initialize_notebook();
1141 }
1142 g_free(filename);
1143 }
1144 }
1145
1146 G_MODULE_EXPORT void onNew(GtkWidget* self, gpointer data) {
1147 gchar* filename = get_filename(FILE_NEW, "New File");
1148 commit(filename);
1149 g_free(filename);
1150 }
1151
1152 G_MODULE_EXPORT void onSave(GtkWidget* self, gpointer data) {
1153 gchar* filename = get_filename(FILE_SAVE, "Save File");
1154 commit(filename);
1155 g_free(filename);
1156 }
1157
1158 gboolean init_gui() {
1159 gboolean fail = TRUE;
1160
1161 builder = gtk_builder_new_from_string(lensdatabase_ui, lensdatabase_ui_len);
1162
1163 if (builder != NULL) {
1164 fail = FALSE;
1165 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
1166 GtkAccelGroup* accel_group = gtk_accel_group_new();
1167 gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
1168
1169
1170 GtkWidget* menu_item_new = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_new"));
1171 gtk_widget_add_accelerator(menu_item_new, "activate", accel_group, GDK_KEY_n, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1172
1173 GtkWidget* menu_item_open = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_open"));
1174 gtk_widget_add_accelerator(menu_item_open, "activate", accel_group, GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1175
1176 GtkWidget* menu_item_save = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_save"));
1177 gtk_widget_add_accelerator(menu_item_save, "activate", accel_group, GDK_KEY_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1178
1179 GtkWidget* menu_item_save_as = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_save_as"));
1180 gtk_widget_add_accelerator(menu_item_save_as, "activate", accel_group, GDK_KEY_a, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1181
1182 GtkWidget* menu_item_quit = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_quit"));
1183 gtk_widget_add_accelerator(menu_item_quit, "activate", accel_group, GDK_KEY_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1184
1185 GtkWidget* add_maker = GTK_WIDGET(gtk_builder_get_object(builder, "add_maker"));
1186 GtkWidget* add_image = gtk_image_new_from_pixbuf(get_btn_image_maker_new());
1187 gtk_button_set_image(GTK_BUTTON(add_maker), add_image);
1188
1189 GtkWidget* del_maker = GTK_WIDGET(gtk_builder_get_object(builder, "del_maker"));
1190 GtkWidget* del_image = gtk_image_new_from_pixbuf(get_btn_maker_remove_image());
1191 gtk_button_set_image(GTK_BUTTON(del_maker), del_image);
1192
1193 GtkWidget* about_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "about_dialog"));
1194 gtk_window_set_transient_for(GTK_WINDOW(about_dialog), GTK_WINDOW(window));
1195 gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(about_dialog), COMMENT);
1196 gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(about_dialog), PACKAGE_NAME);
1197 gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about_dialog), VERSION);
1198
1199 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
1200 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
1201 gtk_text_buffer_set_text(buffer, placeholder_str, -1);
1202
1203 gtk_builder_connect_signals(builder, builder);
1204
1205 initialize_notebook();
1206
1207 gtk_widget_show(window);
1208
1209 gtk_main();
1210 }
1211
1212 return fail;
1213 }
This page took 0.884847 seconds and 6 git commands to generate.