]> git.datanom.net - gtk_lensdatabase.git/blob - src/gui.c
On the way
[gtk_lensdatabase.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
722 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
723 gint cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
724 GtkWidget* child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), cur_page);
725 const gchar* label = gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), child);
726
727 gchar* path = get_image_file();
728 if (path) {
729 GtkWidget* close_btn = GTK_WIDGET(gtk_builder_get_object(builder, "btn_input_close"));
730 g_object_set(G_OBJECT(close_btn), "can-default", TRUE, "has-default", TRUE, NULL);
731
732 Scanner_t* sc = scanner_create(path);
733
734 gchar* sn = get_lens_serial_number(sc);
735 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
736 gtk_entry_set_text(GTK_ENTRY(entry_sn), g_strdup(sn));
737 //row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
738 g_free(sn);
739
740 gchar* data = get_lens_info(sc);
741 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
742 gtk_entry_set_text(GTK_ENTRY(entry_data), g_strdup(data));
743 //row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
744 g_free(data);
745
746 gchar* lens_maker = get_lens_maker(sc);
747 //GtkTextIter start, end;
748 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
749 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
750 gtk_text_buffer_set_text(buffer, g_strdup_printf("Data Scanned from %s", path), -1);
751 //row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
752
753 scanner_destroy(sc);
754
755 /* New lens */
756 /*
757 * 1. Create maker if not exist
758 * 2. Change tab if maker is is not current tab
759 * 3. Update input_label to the current tab
760 */
761 GtkWidget* header = GTK_WIDGET(gtk_builder_get_object(builder, "label_input_header"));
762 Maker* maker = NULL;
763 gchar* dialog_label = NULL;
764
765 if (lens_maker) {
766 gint id;
767
768 if (label && g_ascii_strcasecmp(label, lens_maker) == 0) {
769 /* lens_maker same as than current maker */
770 } else {
771 id = get_maker_id(lens_maker);
772 if (id != -1) {
773 /* Change tab */
774 maker = get_maker(id);
775 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), maker->page);
776 dialog_label = g_strconcat("New [", maker->maker_name,"] Lens", NULL);
777 gtk_label_set_text(GTK_LABEL(header), dialog_label);
778 g_free(dialog_label);
779 } else {
780 /* Ask to add to current maker */
781 gchar* error = NULL;
782
783 id = add_maker(lens_maker, &error);
784 if (id != -1) {
785 add_row(id, NULL);
786 maker = get_maker(id);
787 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), maker->page);
788 dialog_label = g_strconcat("New [", maker->maker_name,"] Lens", NULL);
789 gtk_label_set_text(GTK_LABEL(header), dialog_label);
790 g_free(dialog_label);
791 }
792 g_free(error);
793 }
794 }
795 } else {
796 /* New lens for current maker */
797 }
798 maker_free(maker);
799 g_free(lens_maker);
800 }
801
802 g_free(path);
803 row_free(row, NULL);
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_message(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_message(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 input_move_clicked_cb(GtkWidget* self, gpointer data) {
878 GtkWidget *dialog, *content_area, *combo;
879
880 GtkWidget* parent = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
881 GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
882 dialog = gtk_dialog_new_with_buttons("New Maker",
883 GTK_WINDOW(parent),
884 flags,
885 "_OK",
886 GTK_RESPONSE_ACCEPT,
887 "_Cancel",
888 GTK_RESPONSE_REJECT,
889 NULL);
890
891 content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
892 combo = gtk_combo_box_text_new();
893 GSList* makers = get_makers();
894
895 for (GSList* elem = makers; elem; elem = elem->next) {
896 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), g_strdup((const gchar*)elem->data));
897 }
898 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
899 gtk_widget_show_all(combo);
900
901 g_slist_foreach(makers, (GFunc)g_free, NULL);
902 g_slist_free(makers);
903
904 gtk_container_add(GTK_CONTAINER(content_area), combo);
905
906 gint response = gtk_dialog_run(GTK_DIALOG(dialog));
907 if (response == GTK_RESPONSE_ACCEPT) {
908 Row* row = row_new();
909
910 gchar* maker = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
911 row->maker = get_maker_id(maker);
912 g_free(maker);
913
914 GtkWidget* entry_id = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_id"));
915 row->id = atol(gtk_entry_get_text(GTK_ENTRY(entry_id)));
916
917 GtkWidget* entry_sn = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_sn"));
918 row->sn = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_sn)));
919
920 GtkWidget* entry_data = GTK_WIDGET(gtk_builder_get_object(builder, "entry_input_data"));
921 row->data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry_data)));
922
923 GtkTextIter start, end;
924 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
925 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
926 gtk_text_buffer_get_bounds (buffer, &start, &end);
927 row->notes = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
928
929 if (cur_view != NULL) {
930 if (update_lens_maker(row)) {
931 gchar* err = g_strdup_printf("Update failed: [id: %ld, sn: %s, data: %s, notes: %s]\n", row->id, row->sn, row->data, row->notes);
932 fprintf(stderr, err);
933 show_message(GTK_MESSAGE_ERROR, err);
934 g_free(err);
935 }
936 GtkListStore* store = GTK_LIST_STORE(gtk_tree_view_get_model(cur_view));
937 gtk_list_store_remove(store, &cur_iter);
938 add_row(row->maker, row);
939 }
940
941 row_free(row, NULL);
942 cur_view = NULL;
943 }
944 gtk_widget_destroy(dialog);
945
946 hide_input_dialog();
947 }
948
949 G_MODULE_EXPORT void search_result_ok_clicked_cb(GtkWidget* self, gpointer data) {
950 hide_search_result_dialog();
951 }
952
953 typedef enum {
954 FILE_SAVE_AS,
955 FILE_SAVE,
956 FILE_NEW,
957 FILE_OPEN
958 } FileAction;
959
960 static gchar* get_filename(FileAction fileAction, const gchar* title) {
961 GtkWidget *dialog;
962 GtkFileChooser *chooser;
963 GtkFileChooserAction action;
964 gint res;
965 GtkWidget* parent_window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
966 gchar* nameHint = NULL;
967 gchar* current_dir = NULL;
968
969 if (current_filename != NULL) {
970 current_dir = g_path_get_dirname(current_filename);
971 nameHint = g_path_get_basename(current_filename);
972 }
973 switch (fileAction) {
974 case FILE_SAVE_AS:
975 g_free(nameHint);
976 nameHint = g_strdup("Untitled document.csv");
977 action = GTK_FILE_CHOOSER_ACTION_SAVE;
978 break;
979 case FILE_SAVE:
980 if (nameHint == NULL)
981 nameHint = g_strdup("Untitled document.csv");
982 action = GTK_FILE_CHOOSER_ACTION_SAVE;
983 break;
984 case FILE_NEW:
985 g_free(nameHint);
986 nameHint = g_strdup("Untitled document.csv");
987 action = GTK_FILE_CHOOSER_ACTION_SAVE;
988 break;
989 case FILE_OPEN:
990 action = GTK_FILE_CHOOSER_ACTION_OPEN;
991 break;
992 }
993
994 if (FILE_OPEN == fileAction) {
995 dialog = gtk_file_chooser_dialog_new(title,
996 GTK_WINDOW(parent_window),
997 action,
998 ("_Cancel"),
999 GTK_RESPONSE_CANCEL,
1000 ("_Open"),
1001 GTK_RESPONSE_ACCEPT,
1002 NULL);
1003 } else {
1004 dialog = gtk_file_chooser_dialog_new(title,
1005 GTK_WINDOW(parent_window),
1006 action,
1007 ("_Cancel"),
1008 GTK_RESPONSE_CANCEL,
1009 ("_Save"),
1010 GTK_RESPONSE_ACCEPT,
1011 NULL);
1012 }
1013
1014 chooser = GTK_FILE_CHOOSER(dialog);
1015
1016 GtkFileFilter* filter_csv = gtk_file_filter_new();
1017 gtk_file_filter_add_mime_type(filter_csv, "text/csv");
1018 gtk_file_filter_add_mime_type(filter_csv, "application/csv");
1019 gtk_file_filter_add_mime_type(filter_csv, "application/x-csv");
1020 gtk_file_filter_add_mime_type(filter_csv, "application/vnd.ms-excel");
1021 gtk_file_filter_add_mime_type(filter_csv, "text/x-csv");
1022 gtk_file_filter_add_mime_type(filter_csv, "text/comma-separated-values");
1023 gtk_file_filter_add_mime_type(filter_csv, "text/x-comma-separated-values");
1024 gtk_file_filter_add_mime_type(filter_csv, "text/tab-separated-values");
1025 gtk_file_filter_add_pattern(filter_csv, "*.csv");
1026 gtk_file_filter_set_name(filter_csv, "CSV files");
1027 gtk_file_chooser_add_filter(chooser, filter_csv);
1028 GtkFileFilter* filter_plain = gtk_file_filter_new();
1029 gtk_file_filter_add_mime_type(filter_plain, "text/plain");
1030 gtk_file_filter_set_name(filter_plain, "Plain text");
1031 gtk_file_chooser_add_filter(chooser, filter_plain);
1032
1033 if (FILE_OPEN != fileAction) {
1034 gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
1035 GtkFileFilter* filter_all = gtk_file_filter_new();
1036 gtk_file_filter_add_pattern(filter_all, "*");
1037 gtk_file_filter_set_name(filter_all, "All files");
1038 gtk_file_chooser_add_filter(chooser, filter_all);
1039 gtk_file_chooser_set_current_name(chooser, nameHint);
1040 }
1041
1042 if (current_dir != NULL)
1043 gtk_file_chooser_set_current_folder(chooser, current_dir);
1044
1045 res = gtk_dialog_run(GTK_DIALOG(dialog));
1046 if (res == GTK_RESPONSE_ACCEPT) {
1047 g_free(current_filename);
1048 current_filename = gtk_file_chooser_get_filename(chooser);
1049 }
1050
1051 gtk_widget_destroy (dialog);
1052 g_free(nameHint);
1053 g_free(current_dir);
1054
1055 return res == GTK_RESPONSE_ACCEPT ? g_strdup(current_filename) : NULL;
1056 }
1057
1058 void commit(const gchar* filename) {
1059 CvsError* err = NULL;
1060
1061 if (filename) {
1062 Instructions instructions = {
1063 .file = filename,
1064 .write = true,
1065 .overwrite = true,
1066 .first_line_header = true
1067 };
1068 CsvParser* parser = csv_parser_new(&instructions, &err);
1069 if (parser) {
1070 dump_storage(parser);
1071 csv_parser_free(parser);
1072 } else {
1073 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
1074 csv_error_clear(&err);
1075 }
1076 }
1077 }
1078
1079 G_MODULE_EXPORT void onSaveAs(GtkWidget* self, gpointer data) {
1080 gchar* filename = get_filename(FILE_NEW, "New File");
1081 commit(filename);
1082 g_free(filename);
1083 }
1084
1085 G_MODULE_EXPORT void onOpen(GtkWidget* self, gpointer data) {
1086 CvsError* err = NULL;
1087 gchar* cvsErr = NULL;
1088 bool replace = false;
1089 GtkWidget* notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
1090
1091 gchar* filename = get_filename(FILE_OPEN, "Open File");
1092 if (filename) {
1093 Instructions instructions = {
1094 .file = filename,
1095 .first_line_header = true,
1096 .write = false,
1097 .overwrite = false
1098 };
1099 CsvParser* parser = csv_parser_new(&instructions, &err);
1100 if (!parser) {
1101 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
1102 csv_error_clear(&err);
1103 } else {
1104 if ((replace = show_message(GTK_MESSAGE_QUESTION, "Should file content replace current?")) == true) {
1105 for (gint i = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook)); i > 0; i--) {
1106 GtkWidget* window = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), i-1);
1107 GtkWidget* treeview = gtk_bin_get_child(GTK_BIN(window));
1108 GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
1109 GtkListStore* store = GTK_LIST_STORE(model);
1110 gtk_list_store_clear(store);
1111 //gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), NULL);
1112 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), i-1);
1113 gtk_widget_queue_draw(GTK_WIDGET(notebook));
1114 }
1115 GSList* makers = get_makers();
1116 for (GSList* elem = makers; elem; elem = elem->next) {
1117 Maker* maker = get_maker(get_maker_id(elem->data));
1118 delete_maker(maker->maker_name, &cvsErr);
1119 maker_free(maker);
1120 }
1121 g_slist_foreach(makers, (GFunc)g_free, NULL);
1122 g_slist_free(makers);
1123 }
1124 Record* r = NULL;
1125 while ((r = csv_parser_next_line(parser, &err)) != NULL) {
1126 if (err) {
1127 fprintf(stderr, "[Line: %zu - %s]\n", err->line, err->message);
1128 csv_error_clear(&err);
1129 }
1130 gint id;
1131 if ((id = get_maker_id(r->maker)) == -1) {
1132 id = add_maker(r->maker, &cvsErr);
1133 }
1134 Row* row = row_new();
1135 row->maker = id;
1136 row->sn = g_strdup(r->sn);
1137 row->data = g_strdup(r->data);
1138 row->notes = g_strdup(r->notes);
1139 csv_record_free(r);
1140 add_lens(row);
1141 if (!replace)
1142 add_row(row->maker, row);
1143 row_free(row, NULL);
1144 }
1145 csv_parser_free(parser);
1146 if (replace)
1147 initialize_notebook();
1148 }
1149 g_free(filename);
1150 }
1151 }
1152
1153 G_MODULE_EXPORT void onNew(GtkWidget* self, gpointer data) {
1154 gchar* filename = get_filename(FILE_NEW, "New File");
1155 commit(filename);
1156 g_free(filename);
1157 }
1158
1159 G_MODULE_EXPORT void onSave(GtkWidget* self, gpointer data) {
1160 gchar* filename = get_filename(FILE_SAVE, "Save File");
1161 commit(filename);
1162 g_free(filename);
1163 }
1164
1165 gboolean init_gui() {
1166 gboolean fail = TRUE;
1167
1168 builder = gtk_builder_new_from_string(lensdatabase_ui, lensdatabase_ui_len);
1169
1170 if (builder != NULL) {
1171 fail = FALSE;
1172 GtkWidget* window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window"));
1173 GtkAccelGroup* accel_group = gtk_accel_group_new();
1174 gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
1175
1176
1177 GtkWidget* menu_item_new = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_new"));
1178 gtk_widget_add_accelerator(menu_item_new, "activate", accel_group, GDK_KEY_n, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1179
1180 GtkWidget* menu_item_open = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_open"));
1181 gtk_widget_add_accelerator(menu_item_open, "activate", accel_group, GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1182
1183 GtkWidget* menu_item_save = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_save"));
1184 gtk_widget_add_accelerator(menu_item_save, "activate", accel_group, GDK_KEY_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1185
1186 GtkWidget* menu_item_save_as = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_save_as"));
1187 gtk_widget_add_accelerator(menu_item_save_as, "activate", accel_group, GDK_KEY_a, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1188
1189 GtkWidget* menu_item_quit = GTK_WIDGET(gtk_builder_get_object(builder, "Menu_item_quit"));
1190 gtk_widget_add_accelerator(menu_item_quit, "activate", accel_group, GDK_KEY_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
1191
1192 GtkWidget* add_maker = GTK_WIDGET(gtk_builder_get_object(builder, "add_maker"));
1193 GtkWidget* add_image = gtk_image_new_from_pixbuf(get_btn_image_maker_new());
1194 gtk_button_set_image(GTK_BUTTON(add_maker), add_image);
1195
1196 GtkWidget* del_maker = GTK_WIDGET(gtk_builder_get_object(builder, "del_maker"));
1197 GtkWidget* del_image = gtk_image_new_from_pixbuf(get_btn_maker_remove_image());
1198 gtk_button_set_image(GTK_BUTTON(del_maker), del_image);
1199
1200 GtkWidget* about_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "about_dialog"));
1201 gtk_window_set_transient_for(GTK_WINDOW(about_dialog), GTK_WINDOW(window));
1202 gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(about_dialog), COMMENT);
1203 gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(about_dialog), PACKAGE_NAME);
1204 gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about_dialog), VERSION);
1205
1206 GtkWidget* textview = GTK_WIDGET(gtk_builder_get_object(builder, "textview_input_notes"));
1207 GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
1208 gtk_text_buffer_set_text(buffer, placeholder_str, -1);
1209
1210 gtk_builder_connect_signals(builder, builder);
1211
1212 initialize_notebook();
1213
1214 gtk_widget_show(window);
1215
1216 gtk_main();
1217 }
1218
1219 return fail;
1220 }
This page took 2.148315 seconds and 6 git commands to generate.