]> Dogcows Code - chaz/homebank/blob - src/ui-assist-import.c
projects / chaz / homebank / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
import homebank-5.2.4
[chaz/homebank] / src / ui-assist-import.c
1 /* HomeBank -- Free, easy, personal accounting for everyone.
2 * Copyright (C) 1995-2019 Maxime DOYEN
3 *
4 * This file is part of HomeBank.
5 *
6 * HomeBank 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 2 of the License, or
9 * (at your option) any later version.
10 *
11 * HomeBank 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, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "homebank.h"
21
22 #include "hb-import.h"
23 #include "ui-assist-import.h"
24 #include "dsp-mainwindow.h"
25 #include "list-operation.h"
26
27
28 /****************************************************************************/
29 /* Debug macros */
30 /****************************************************************************/
31 #define MYDEBUG 0
32
33 #if MYDEBUG
34 #define DB(x) (x);
35 #else
36 #define DB(x);
37 #endif
38
39
40 /* our global datas */
41 extern struct HomeBank *GLOBALS;
42 extern struct Preferences *PREFS;
43
44
45
46 extern gchar *CYA_IMPORT_DATEORDER[];
47
48 extern gchar *CYA_IMPORT_OFXNAME[];
49 extern gchar *CYA_IMPORT_OFXMEMO[];
50
51
52 static void ui_import_page_filechooser_eval(GtkWidget *widget, gpointer user_data);
53
54
55 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
56
57
58 #if MYDEBUG == 1
59 static void list_txn_cell_data_function_debug (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
60 {
61 GenTxn *gentxn;
62 gchar *text;
63
64 gtk_tree_model_get(model, iter,
65 LST_GENTXN_POINTER, &gentxn,
66 -1);
67
68 text = g_strdup_printf("%d %d > %d", gentxn->is_imp_similar, gentxn->is_dst_similar, gentxn->to_import);
69
70 g_object_set(renderer,
71 "text", text,
72 NULL);
73
74 g_free(text);
75 }
76 #endif
77
78
79 static void list_txn_cell_data_function_toggle (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
80 {
81 GenTxn *gentxn;
82
83 gtk_tree_model_get(model, iter,
84 LST_GENTXN_POINTER, &gentxn,
85 -1);
86
87 g_object_set(renderer, "active", gentxn->to_import, NULL);
88 }
89
90
91 static void list_txn_cell_data_function_warning (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
92 {
93 GenTxn *gentxn;
94 gchar *iconname = NULL;
95
96 // get the transaction
97 gtk_tree_model_get(model, iter,
98 LST_GENTXN_POINTER, &gentxn,
99 -1);
100
101 //iconname = ( gentxn->julian == 0 ) ? ICONNAME_WARNING : NULL;
102 //if(iconname == NULL)
103 iconname = ( gentxn->is_dst_similar || gentxn->is_imp_similar ) ? ICONNAME_HB_OPE_SIMILAR : NULL;
104
105 g_object_set(renderer, "icon-name", iconname, NULL);
106 }
107
108
109 static void list_txn_cell_data_function_error (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
110 {
111 GenTxn *gentxn;
112 gchar *iconname = NULL;
113
114 // get the transaction
115 gtk_tree_model_get(model, iter,
116 LST_GENTXN_POINTER, &gentxn,
117 -1);
118
119 iconname = ( gentxn->julian == 0 ) ? ICONNAME_ERROR : NULL;
120
121 g_object_set(renderer, "icon-name", iconname, NULL);
122 }
123
124
125 static void list_txn_cell_data_function_text (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
126 {
127 gint colid = GPOINTER_TO_INT(user_data);
128 gchar buf[12];
129 GDate date;
130 gchar *text = "";
131 GenTxn *item;
132
133 gtk_tree_model_get(model, iter,
134 LST_GENTXN_POINTER, &item,
135 -1);
136
137 switch(colid)
138 {
139 case LST_DSPOPE_DATE: //date
140 {
141 gchar *color = NULL;
142
143 if(item->julian > 0)
144 {
145 g_date_set_julian(&date, item->julian);
146 //#1794170 %F is ignored under ms windows
147 //g_date_strftime (buf, 12-1, "%F", &date);
148 g_date_strftime (buf, 12-1, "%Y-%m-%d", &date);
149 text = buf;
150 }
151 else
152 {
153 text = item->date;
154 color = PREFS->color_warn;
155 }
156
157 g_object_set(renderer,
158 "foreground", color,
159 NULL);
160 }
161 //g_object_set(renderer, "text", item->date, NULL);
162 break;
163 case LST_DSPOPE_MEMO: //memo
164 text = item->memo;
165 break;
166 case LST_DSPOPE_PAYEE: //payee
167 text = item->payee;
168 break;
169 case LST_DSPOPE_CATEGORY: //category
170 text = item->category;
171 break;
172 }
173
174 g_object_set(renderer,
175 "text", text,
176 //"scale-set", TRUE,
177 //"scale", item->to_import ? 1.0 : 0.8,
178 "strikethrough-set", TRUE,
179 "strikethrough", item->to_import ? FALSE : TRUE,
180 NULL);
181
182 }
183
184
185 /*
186 ** amount cell function
187 */
188 static void list_txn_cell_data_function_amount (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
189 {
190 GenTxn *item;
191 gchar formatd_buf[G_ASCII_DTOSTR_BUF_SIZE];
192 gchar *color;
193
194 gtk_tree_model_get(model, iter,
195 LST_GENTXN_POINTER, &item,
196 -1);
197
198 //todo: we could use digit and currency of target account
199 //hb_strfnum(buf, G_ASCII_DTOSTR_BUF_SIZE-1, item->amount, GLOBALS->kcur, FALSE);
200 //hb_strfmon(buf, G_ASCII_DTOSTR_BUF_SIZE-1, ope->amount, GLOBALS->minor);
201 g_ascii_formatd(formatd_buf, G_ASCII_DTOSTR_BUF_SIZE-1, "%.2f", item->amount);
202
203 color = get_normal_color_amount(item->amount);
204
205 g_object_set(renderer,
206 "foreground", color,
207 "text", formatd_buf,
208 NULL);
209
210 }
211
212
213 static void list_txn_cell_data_function_info (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
214 {
215 GenTxn *item;
216
217 gtk_tree_model_get(model, iter,
218 LST_GENTXN_POINTER, &item,
219 -1);
220
221 switch(GPOINTER_TO_INT(user_data))
222 {
223 case 1:
224 g_object_set(renderer, "icon-name", get_paymode_icon_name(item->paymode), NULL);
225 break;
226 case 2:
227 g_object_set(renderer, "text", item->info, NULL);
228 break;
229 }
230 }
231
232
233 static void list_txn_importfixed_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
234 {
235 GtkTreeModel *model = (GtkTreeModel *)data;
236 GtkTreeIter iter;
237 GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
238 GenTxn *gentxn;
239
240 gtk_tree_model_get_iter (model, &iter, path);
241 gtk_tree_model_get (model, &iter, LST_GENTXN_POINTER, &gentxn, -1);
242 gentxn->to_import ^= 1;
243 gtk_tree_path_free (path);
244 }
245
246
247 static gint list_txn_import_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
248 {
249 gint sortcol = GPOINTER_TO_INT(userdata);
250 gint retval = 0;
251 GenTxn *gentxn1, *gentxn2;
252
253 gtk_tree_model_get(model, a, LST_GENTXN_POINTER, &gentxn1, -1);
254 gtk_tree_model_get(model, b, LST_GENTXN_POINTER, &gentxn2, -1);
255
256 switch(sortcol)
257 {
258 case LST_DSPOPE_MEMO:
259 retval = hb_string_utf8_compare(gentxn1->memo, gentxn2->memo);
260 break;
261 case LST_DSPOPE_AMOUNT:
262 retval = (gentxn1->amount - gentxn2->amount) > 0 ? 1 : -1;
263 break;
264 case LST_DSPOPE_PAYEE:
265 retval = hb_string_utf8_compare(gentxn1->payee, gentxn2->payee);
266 break;
267 case LST_DSPOPE_CATEGORY:
268 retval = hb_string_utf8_compare(gentxn1->category, gentxn2->category);
269 break;
270 case LST_DSPOPE_DATE:
271 default:
272 retval = gentxn1->julian - gentxn2->julian;
273 break;
274 }
275
276 return retval;
277 }
278
279
280 static GtkTreeViewColumn *
281 list_txn_import_column_text_create(gchar *title, gint sortcolumnid, gpointer user_data)
282 {
283 GtkTreeViewColumn *column;
284 GtkCellRenderer *renderer;
285
286 renderer = gtk_cell_renderer_text_new ();
287 /*g_object_set(renderer,
288 "ellipsize", PANGO_ELLIPSIZE_END,
289 "ellipsize-set", TRUE,
290 NULL);*/
291 if( sortcolumnid == LST_DSPOPE_AMOUNT )
292 g_object_set(renderer, "xalign", 1.0, NULL);
293
294 column = gtk_tree_view_column_new_with_attributes(title, renderer, NULL);
295 gtk_tree_view_column_set_alignment (column, 0.5);
296 gtk_tree_view_column_set_sort_column_id (column, sortcolumnid);
297
298 if(sortcolumnid == LST_DSPOPE_AMOUNT )
299 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_amount, GINT_TO_POINTER(sortcolumnid), NULL);
300 else
301 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_text, GINT_TO_POINTER(sortcolumnid), NULL);
302
303 return column;
304 }
305
306
307
308 static GtkWidget *list_txn_import_create(void)
309 {
310 GtkListStore *store;
311 GtkWidget *treeview;
312 GtkCellRenderer *renderer;
313 GtkTreeViewColumn *column;
314
315 /* create list store */
316 store = gtk_list_store_new(
317 NUM_LST_GENTXN,
318 G_TYPE_POINTER
319 );
320
321 //treeview
322 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
323 g_object_unref(store);
324
325 gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (treeview), PREFS->grid_lines|GTK_TREE_VIEW_GRID_LINES_VERTICAL);
326
327 // debug/import checkbox
328 column = gtk_tree_view_column_new();
329 #if MYDEBUG == 1
330 renderer = gtk_cell_renderer_text_new ();
331 gtk_tree_view_column_pack_start(column, renderer, TRUE);
332 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_debug, NULL, NULL);
333 #endif
334 renderer = gtk_cell_renderer_toggle_new ();
335 gtk_tree_view_column_pack_start(column, renderer, TRUE);
336 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_toggle, NULL, NULL);
337 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
338 g_signal_connect (renderer, "toggled", G_CALLBACK (list_txn_importfixed_toggled), store);
339
340 // icons
341 column = gtk_tree_view_column_new();
342 //gtk_tree_view_column_set_title(column, _("Import ?"));
343 renderer = gtk_cell_renderer_pixbuf_new ();
344 //gtk_cell_renderer_set_fixed_size(renderer, 16, -1);
345 //gtk_cell_renderer_set_fixed_size(renderer, GLOBALS->lst_pixbuf_maxwidth, -1);
346 gtk_tree_view_column_pack_start(column, renderer, TRUE);
347 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_warning, NULL, NULL);
348 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
349
350 // date
351 column = gtk_tree_view_column_new();
352 renderer = gtk_cell_renderer_pixbuf_new ();
353 gtk_tree_view_column_pack_start(column, renderer, TRUE);
354 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_error, NULL, NULL);
355 renderer = gtk_cell_renderer_text_new ();
356 gtk_tree_view_column_pack_start(column, renderer, TRUE);
357 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_text, GINT_TO_POINTER(LST_DSPOPE_DATE), NULL);
358 gtk_tree_view_column_set_title (column, _("Date"));
359 gtk_tree_view_column_set_sort_column_id (column, LST_DSPOPE_DATE);
360 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
361
362 // memo
363 column = list_txn_import_column_text_create(_("Memo"), LST_DSPOPE_MEMO, NULL);
364 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
365
366 // amount
367 column = list_txn_import_column_text_create(_("Amount"), LST_DSPOPE_AMOUNT, NULL);
368 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
369
370 // info
371 column = gtk_tree_view_column_new();
372 gtk_tree_view_column_set_title(column, _("Info"));
373 renderer = gtk_cell_renderer_pixbuf_new ();
374 gtk_tree_view_column_pack_start(column, renderer, TRUE);
375 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_info, GINT_TO_POINTER(1), NULL);
376 renderer = gtk_cell_renderer_text_new ();
377 /*g_object_set(renderer,
378 "ellipsize", PANGO_ELLIPSIZE_END,
379 "ellipsize-set", TRUE,
380 NULL);*/
381 gtk_tree_view_column_pack_start(column, renderer, TRUE);
382 gtk_tree_view_column_set_cell_data_func(column, renderer, list_txn_cell_data_function_info, GINT_TO_POINTER(2), NULL);
383 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
384
385 // payee
386 column = list_txn_import_column_text_create(_("Payee"), LST_DSPOPE_PAYEE, NULL);
387 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
388
389 // category
390 column = list_txn_import_column_text_create(_("Category"), LST_DSPOPE_CATEGORY, NULL);
391 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
392
393 // empty
394 column = gtk_tree_view_column_new();
395 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
396
397 //gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), list_txn_import_compare_func, NULL, NULL);
398 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DSPOPE_DATE , list_txn_import_compare_func, GINT_TO_POINTER(LST_DSPOPE_DATE), NULL);
399 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DSPOPE_MEMO , list_txn_import_compare_func, GINT_TO_POINTER(LST_DSPOPE_MEMO), NULL);
400 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DSPOPE_AMOUNT , list_txn_import_compare_func, GINT_TO_POINTER(LST_DSPOPE_AMOUNT), NULL);
401 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DSPOPE_PAYEE , list_txn_import_compare_func, GINT_TO_POINTER(LST_DSPOPE_PAYEE), NULL);
402 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DSPOPE_CATEGORY, list_txn_import_compare_func, GINT_TO_POINTER(LST_DSPOPE_CATEGORY), NULL);
403
404 return(treeview);
405 }
406
407
408 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
409
410 static gint ui_genacc_comboboxtext_get_active(GtkWidget *widget)
411 {
412 GtkTreeModel *model;
413 GtkTreeIter iter;
414 gint key = -1;
415
416 g_return_val_if_fail(GTK_IS_COMBO_BOX(widget), key);
417
418 if( gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
419 {
420 model = gtk_combo_box_get_model (GTK_COMBO_BOX(widget));
421
422 gtk_tree_model_get(model, &iter,
423 LST_GENACC_KEY, &key,
424 -1);
425 }
426 return key;
427 }
428
429
430 static void ui_genacc_comboboxtext_set_active(GtkWidget *widget, gint active_key)
431 {
432 GtkTreeModel *model;
433 GtkTreeIter iter;
434 gboolean valid;
435 gint key;
436
437 g_return_if_fail(GTK_IS_COMBO_BOX(widget));
438
439 model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
440 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
441 while (valid)
442 {
443 gtk_tree_model_get(model, &iter,
444 LST_GENACC_KEY, &key,
445 -1);
446 if(key == active_key)
447 gtk_combo_box_set_active_iter (GTK_COMBO_BOX(widget), &iter);
448
449 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
450 }
451 }
452
453
454 static GtkWidget *ui_genacc_comboboxtext_new(struct import_data *data, GtkWidget *label)
455 {
456 GtkListStore *store;
457 GtkCellRenderer *renderer;
458 GtkWidget *combobox;
459 GtkTreeIter iter;
460 GList *lacc, *list;
461
462 store = gtk_list_store_new (NUM_LST_GENACC, G_TYPE_STRING, G_TYPE_INT);
463 combobox = gtk_combo_box_new_with_model (GTK_TREE_MODEL(store));
464
465 renderer = gtk_cell_renderer_text_new();
466 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox), renderer, FALSE);
467 gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(combobox), renderer, "text", LST_GENACC_NAME);
468
469 g_object_unref(store);
470
471 gtk_list_store_insert_with_values (GTK_LIST_STORE(store), &iter, -1,
472 LST_GENACC_NAME, _("<New account (global)>"),
473 LST_GENACC_KEY, DST_ACC_GLOBAL,
474 -1);
475
476 gtk_list_store_insert_with_values (GTK_LIST_STORE(store), &iter, -1,
477 LST_GENACC_NAME, _("<New account>"),
478 LST_GENACC_KEY, DST_ACC_NEW,
479 -1);
480
481 lacc = list = account_glist_sorted(0);
482 while (list != NULL)
483 {
484 Account *item = list->data;
485
486 if( !(item->flags & AF_CLOSED) )
487 {
488 gtk_list_store_insert_with_values (GTK_LIST_STORE(store), &iter, -1,
489 LST_GENACC_NAME, item->name,
490 LST_GENACC_KEY, item->key,
491 -1);
492 }
493 list = g_list_next(list);
494 }
495 g_list_free(lacc);
496
497 gtk_list_store_insert_with_values (GTK_LIST_STORE(store), &iter, -1,
498 LST_GENACC_NAME, _("<Skip this account>"),
499 LST_GENACC_KEY, DST_ACC_SKIP,
500 -1);
501
502 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
503
504 if(label)
505 gtk_label_set_mnemonic_widget (GTK_LABEL(label), combobox);
506
507
508 return combobox;
509 }
510
511
512 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
513
514
515 enum
516 {
517 TARGET_URI_LIST
518 };
519
520 static GtkTargetEntry drop_types[] =
521 {
522 {"text/uri-list", 0, TARGET_URI_LIST}
523 };
524
525
526 static void
527 list_file_add(GtkWidget *treeview, GenFile *genfile)
528 {
529 char *basename;
530 GtkTreeModel *model;
531 GtkTreeIter iter;
532
533 basename = g_path_get_basename(genfile->filepath);
534
535 model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
536
537 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
538 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
539 LST_GENFILE_POINTER, genfile,
540 LST_GENFILE_NAME, g_strdup(basename),
541 -1);
542
543 g_free(basename);
544 }
545
546
547 static void list_file_drag_data_received (GtkWidget *widget,
548 GdkDragContext *context,
549 gint x, gint y,
550 GtkSelectionData *selection_data,
551 guint info, guint time, GtkWindow *window)
552 {
553 struct import_data *data;
554 gchar **uris, **str;
555 gchar *newseldata;
556 gint slen;
557
558 if (info != TARGET_URI_LIST)
559 return;
560
561 DB( g_print("\n[ui-treeview] drag_data_received\n") );
562
563 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
564
565 /* On MS-Windows, it looks like `selection_data->data' is not NULL terminated. */
566 slen = gtk_selection_data_get_length(selection_data);
567 newseldata = g_new (gchar, slen + 1);
568 memcpy (newseldata, gtk_selection_data_get_data(selection_data), slen);
569 newseldata[slen] = 0;
570
571 uris = g_uri_list_extract_uris (newseldata);
572
573 ImportContext *ictx = &data->ictx;
574
575 str = uris;
576 for (str = uris; *str; str++)
577 //if( *str )
578 {
579 GError *error = NULL;
580 gchar *path = g_filename_from_uri (*str, NULL, &error);
581
582 if (path)
583 {
584 GenFile *genfile;
585
586 genfile = da_gen_file_append_from_filename(ictx, path);
587 if(genfile)
588 list_file_add(data->LV_file, genfile);
589 }
590 else
591 {
592 g_warning ("Could not convert uri to local path: %s", error->message);
593 g_error_free (error);
594 }
595 g_free (path);
596 }
597 g_strfreev (uris);
598
599 g_free(newseldata);
600
601 ui_import_page_filechooser_eval(widget, NULL);
602 }
603
604
605 static void
606 list_file_valid_cell_data_function (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
607 {
608 GenFile *genfile;
609 gchar *iconname = NULL;
610
611 gtk_tree_model_get(model, iter,
612 LST_GENFILE_POINTER, &genfile,
613 -1);
614
615 iconname = (genfile->filetype == FILETYPE_UNKNOWN) ? ICONNAME_HB_FILE_INVALID : ICONNAME_HB_FILE_VALID;
616
617 g_object_set(renderer, "icon-name", iconname, NULL);
618 }
619
620
621 static GtkWidget *
622 list_file_new(void)
623 {
624 GtkListStore *store;
625 GtkWidget *treeview;
626 GtkCellRenderer *renderer;
627 GtkTreeViewColumn *column;
628
629 // create list store
630 store = gtk_list_store_new(NUM_LST_FILE,
631 G_TYPE_POINTER,
632 G_TYPE_STRING
633 );
634
635 // treeview
636 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
637 g_object_unref(store);
638
639 //column: valid
640 column = gtk_tree_view_column_new();
641 gtk_tree_view_column_set_title(column, _("Valid"));
642 renderer = gtk_cell_renderer_pixbuf_new ();
643 //gtk_cell_renderer_set_fixed_size(renderer, 16, -1);
644 gtk_tree_view_column_pack_start(column, renderer, TRUE);
645 gtk_tree_view_column_set_cell_data_func(column, renderer, list_file_valid_cell_data_function, NULL, NULL);
646 gtk_tree_view_column_set_alignment (column, 0.5);
647 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
648 g_object_set(renderer, "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
649
650 // column: name
651 renderer = gtk_cell_renderer_text_new ();
652 column = gtk_tree_view_column_new_with_attributes (_("Name"),
653 renderer,
654 "text",
655 LST_GENFILE_NAME,
656 NULL);
657 gtk_tree_view_column_set_sort_column_id (column, LST_GENFILE_NAME);
658 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
659
660
661 // treeviewattribute
662 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview), TRUE);
663
664 //gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), ui_acc_listview_compare_func, NULL, NULL);
665 //gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
666
667 gtk_drag_dest_set (GTK_WIDGET (treeview),
668 GTK_DEST_DEFAULT_ALL,
669 drop_types,
670 G_N_ELEMENTS (drop_types),
671 GDK_ACTION_COPY);
672
673 g_signal_connect (G_OBJECT (treeview), "drag-data-received",
674 G_CALLBACK (list_file_drag_data_received), treeview);
675
676
677 return treeview;
678 }
679
680
681 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
682
683
684 static void ui_import_page_filechooser_remove_action(GtkWidget *widget, gpointer user_data)
685 {
686 struct import_data *data;
687 ImportContext *ictx;
688 GtkTreeModel *model;
689 GtkTreeIter iter;
690 GtkTreeSelection *selection;
691
692 DB( g_print("\n[ui-import] page_filechooser_remove_action\n") );
693
694 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
695 ictx = &data->ictx;
696
697 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_file));
698 //if true there is a selected node
699 if (gtk_tree_selection_get_selected(selection, &model, &iter))
700 {
701 GenFile *genfile;
702
703 gtk_tree_model_get(model, &iter, LST_GENFILE_POINTER, &genfile, -1);
704
705 //remove genacc & gentxn
706 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
707
708 ictx->gen_lst_file = g_list_remove(ictx->gen_lst_file, genfile);
709 da_gen_file_free(genfile);
710 }
711
712 ui_import_page_filechooser_eval(widget, NULL);
713 }
714
715
716 static void ui_import_page_filechooser_add_action(GtkWidget *widget, gpointer user_data)
717 {
718 struct import_data *data;
719 ImportContext *ictx;
720 GtkWidget *dialog;
721 GtkFileFilter *filter;
722 gint res;
723
724 DB( g_print("\n[ui-import] page_filechooser_add_action\n") );
725
726 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
727 ictx = &data->ictx;
728
729 dialog = gtk_file_chooser_dialog_new ("Open File",
730 GTK_WINDOW(data->assistant),
731 GTK_FILE_CHOOSER_ACTION_OPEN,
732 _("_Cancel"),
733 GTK_RESPONSE_CANCEL,
734 _("_Open"),
735 GTK_RESPONSE_ACCEPT,
736 NULL);
737
738 gtk_window_set_position(GTK_WINDOW(data->assistant), GTK_WIN_POS_CENTER_ON_PARENT);
739
740 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog), PREFS->path_import);
741 DB( g_print(" set current folder '%s'\n", PREFS->path_import) );
742
743 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
744
745 filter = gtk_file_filter_new ();
746 gtk_file_filter_set_name (filter, _("Known files"));
747 gtk_file_filter_add_pattern (filter, "*.[Qq][Ii][Ff]");
748 #ifndef NOOFX
749 gtk_file_filter_add_pattern (filter, "*.[OoQq][Ff][Xx]");
750 #endif
751 gtk_file_filter_add_pattern (filter, "*.[Cc][Ss][Vv]");
752 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
753 //if(data->filetype == FILETYPE_UNKNOWN)
754 // gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(dialog), filter);
755
756 filter = gtk_file_filter_new ();
757 gtk_file_filter_set_name (filter, _("QIF files"));
758 gtk_file_filter_add_pattern (filter, "*.[Qq][Ii][Ff]");
759 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
760 //if(data->filetype == FILETYPE_QIF)
761 // gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(dialog), filter);
762
763 #ifndef NOOFX
764 filter = gtk_file_filter_new ();
765 gtk_file_filter_set_name (filter, _("OFX/QFX files"));
766 gtk_file_filter_add_pattern (filter, "*.[OoQq][Ff][Xx]");
767 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
768 //if(data->filetype == FILETYPE_OFX)
769 // gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(dialog), filter);
770 #endif
771
772 filter = gtk_file_filter_new ();
773 gtk_file_filter_set_name (filter, _("CSV files"));
774 gtk_file_filter_add_pattern (filter, "*.[Cc][Ss][Vv]");
775 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
776 //if(data->filetype == FILETYPE_CSV_HB)
777 // gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(dialog), filter);
778
779 filter = gtk_file_filter_new ();
780 gtk_file_filter_set_name (filter, _("All files"));
781 gtk_file_filter_add_pattern (filter, "*");
782 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
783
784
785 res = gtk_dialog_run (GTK_DIALOG (dialog));
786 if (res == GTK_RESPONSE_ACCEPT)
787 {
788 GSList *list;
789
790 GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
791 list = gtk_file_chooser_get_filenames(chooser);
792 while(list)
793 {
794 GenFile *genfile;
795
796 DB( g_print(" selected '%p'\n", list->data) );
797
798 genfile = da_gen_file_append_from_filename(ictx, list->data);
799 if(genfile)
800 list_file_add(data->LV_file, genfile);
801
802 list = g_slist_next(list);
803 }
804 g_slist_free_full (list, g_free);
805
806 /* remind folder to preference */
807 gchar *folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(chooser));
808 DB( g_print(" store folder '%s'\n", folder) );
809 g_free(PREFS->path_import);
810 PREFS->path_import = folder;
811 }
812
813 gtk_widget_destroy (dialog);
814
815 ui_import_page_filechooser_eval(widget, NULL);
816
817 }
818
819
820 static void ui_import_page_confirmation_fill(struct import_data *data)
821 {
822 ImportContext *ictx = &data->ictx;
823 GList *list;
824 GString *node;
825
826 DB( g_print("\n[ui-import] page_confirmation_fill\n") );
827
828 node = g_string_sized_new(255);
829
830 list = g_list_first(ictx->gen_lst_acc);
831 while (list != NULL)
832 {
833 GenAcc *genacc = list->data;
834 gchar *targetname = NULL;
835
836 switch( genacc->kacc )
837 {
838 case DST_ACC_GLOBAL:
839 targetname = _("new global account");
840 break;
841 case DST_ACC_NEW:
842 targetname = _("new account");
843 break;
844 case DST_ACC_SKIP:
845 targetname = _("skipped");
846 break;
847 default:
848 {
849 Account *acc = da_acc_get (genacc->kacc);
850
851 if(acc)
852 targetname = acc->name;
853 }
854 break;
855 }
856
857 //line1: title
858 g_string_append_printf(node, "<b>'%s'</b>\n => '%s'", genacc->name, targetname);
859
860 //line2: count
861 if( genacc->kacc != DST_ACC_SKIP)
862 {
863 hb_import_gen_acc_count_txn(ictx, genacc);
864 g_string_append_printf(node, _(", %d of %d transactions"), genacc->n_txnimp, genacc->n_txnall);
865 }
866
867 g_string_append(node, "\n\n");
868
869 list = g_list_next(list);
870 }
871
872 gtk_label_set_markup (GTK_LABEL(data->TX_summary), node->str);
873
874 g_string_free(node, TRUE);
875 }
876
877
878 static gboolean ui_import_page_import_eval(GtkWidget *widget, gpointer user_data)
879 {
880 //struct import_data *data;
881 //ImportContext *ictx;
882 //gint count;
883
884 DB( g_print("\n[ui-import] page_import_eval\n") );
885
886
887 //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
888 //ictx = &data->ictx;
889
890 //count = g_list_length (ictx->gen_lst_acc);
891
892 //DB( g_print(" count=%d (max=%d)\n", count, TXN_MAX_ACCOUNT) );
893
894 //if( count <= TXN_MAX_ACCOUNT )
895 return TRUE;
896
897 //return FALSE;
898 }
899
900
901 static void ui_import_page_filechooser_eval(GtkWidget *widget, gpointer user_data)
902 {
903 struct import_data *data;
904 ImportContext *ictx;
905 GList *list;
906 gint count = 0;
907
908 DB( g_print("\n[ui-import] page_filechooser_eval\n") );
909
910
911 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
912 ictx = &data->ictx;
913
914 list = g_list_first(ictx->gen_lst_file);
915 while (list != NULL)
916 {
917 GenFile *genfile = list->data;
918
919 if(genfile->filetype != FILETYPE_UNKNOWN)
920 count++;
921
922 list = g_list_next(list);
923 }
924
925 gint index = gtk_assistant_get_current_page(GTK_ASSISTANT(data->assistant));
926 GtkWidget *current_page = gtk_assistant_get_nth_page (GTK_ASSISTANT(data->assistant), index);
927 gtk_assistant_set_page_complete (GTK_ASSISTANT(data->assistant), current_page, (count > 0) ? TRUE : FALSE);
928
929 }
930
931
932 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
933
934
935 static ImpTxnData *ui_import_page_transaction_data_get(GArray *txndata, guint32 idx)
936 {
937 //gint i;
938
939 /*g_print(" array @%p, len is %d\n", txndata, txndata->len);
940 for(i=0;i<txndata->len;i++)
941 g_print(" %d %p\n", i, &g_array_index(txndata, ImpTxnData, i) );
942
943 g_print(" get idx=%d - %p\n", idx, &g_array_index (txndata, ImpTxnData, idx) );
944 */
945
946 if( idx <= txndata->len )
947 return &g_array_index (txndata, ImpTxnData, idx);
948 return NULL;
949 }
950
951
952
953
954 static void ui_import_page_transaction_cb_fill_same(GtkTreeSelection *treeselection, gpointer user_data)
955 {
956 struct import_data *data;
957 ImpTxnData *txndata;
958 //ImportContext *ictx;
959 GtkTreeSelection *selection;
960 GtkTreeModel *model, *dupmodel;
961 GtkTreeIter iter, newiter;
962 GList *tmplist;
963 GtkWidget *widget;
964 guint count = 0;
965
966 DB( g_print("\n[ui-import] page_transaction_cb_fill_same\n") );
967
968 widget = GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection));
969
970 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
971
972 //ictx = &data->ictx;
973
974 gint pageidx = gtk_assistant_get_current_page(GTK_ASSISTANT(data->assistant));
975 gint acckey = pageidx - (PAGE_IMPORT);
976 //GenAcc *genacc = da_gen_acc_get_by_key(ictx->gen_lst_acc, acckey);
977
978 //txndata = &data->txndata[acckey];
979 txndata = ui_import_page_transaction_data_get(data->txndata, acckey);
980
981 dupmodel = gtk_tree_view_get_model(GTK_TREE_VIEW(txndata->LV_duptxn));
982 gtk_list_store_clear (GTK_LIST_STORE(dupmodel));
983
984 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(txndata->LV_gentxn));
985
986 //if true there is a selected node
987 if (gtk_tree_selection_get_selected(selection, &model, &iter))
988 {
989 GenTxn *gentxn;
990
991 gtk_tree_model_get(model, &iter, LST_DSPOPE_DATAS, &gentxn, -1);
992
993 if( gentxn->lst_existing != NULL )
994 {
995 tmplist = g_list_first(gentxn->lst_existing);
996 while (tmplist != NULL)
997 {
998 Transaction *tmp = tmplist->data;
999
1000 /* append to our treeview */
1001 //gtk_list_store_append (GTK_LIST_STORE(dupmodel), &newiter);
1002 //gtk_list_store_set (GTK_LIST_STORE(dupmodel), &newiter,
1003 count++;
1004 gtk_list_store_insert_with_values(GTK_LIST_STORE(dupmodel), &newiter, -1,
1005 LST_DSPOPE_DATAS, tmp,
1006 -1);
1007
1008 //DB( g_print(" - fill: %s %.2f %x\n", item->memo, item->amount, (unsigned int)item->same) );
1009
1010 tmplist = g_list_next(tmplist);
1011 }
1012 }
1013 }
1014
1015 gtk_expander_set_expanded (GTK_EXPANDER(txndata->EX_duptxn), (count > 0) ? TRUE : FALSE);
1016
1017 }
1018
1019
1020 static void ui_import_page_transaction_options_get(struct import_data *data)
1021 {
1022 ImpTxnData *txndata;
1023 ImportContext *ictx;
1024
1025
1026 DB( g_print("\n[ui-import] options_get\n") );
1027
1028 ictx = &data->ictx;
1029
1030 gint pageidx = gtk_assistant_get_current_page(GTK_ASSISTANT(data->assistant));
1031 gint accidx = pageidx - (PAGE_IMPORT);
1032 //GenAcc *genacc = g_list_nth_data(ictx->gen_lst_acc, accidx);
1033
1034 //txndata = &data->txndata[accidx];
1035 txndata = ui_import_page_transaction_data_get(data->txndata, accidx);
1036
1037 ictx->opt_dateorder = gtk_combo_box_get_active (GTK_COMBO_BOX(txndata->CY_txn_dateorder));
1038 ictx->opt_daygap = gtk_spin_button_get_value(GTK_SPIN_BUTTON(txndata->NB_txn_daygap));
1039 ictx->opt_ucfirst = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(txndata->CM_txn_ucfirst));
1040
1041 ictx->opt_ofxname = gtk_combo_box_get_active (GTK_COMBO_BOX(txndata->CY_txn_ofxname));
1042 ictx->opt_ofxmemo = gtk_combo_box_get_active (GTK_COMBO_BOX(txndata->CY_txn_ofxmemo));
1043
1044 ictx->opt_qifmemo = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(txndata->CM_txn_qifmemo));
1045 ictx->opt_qifswap = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(txndata->CM_txn_qifswap));
1046
1047 DB( g_print(" datefmt = '%s' (%d)\n", CYA_IMPORT_DATEORDER[ictx->opt_dateorder], ictx->opt_dateorder) );
1048 }
1049
1050
1051 static void ui_import_page_transaction_update(struct import_data *data)
1052 {
1053 ImpTxnData *txndata;
1054 ImportContext *ictx;
1055 gboolean sensitive, visible;
1056 gboolean iscomplete;
1057 GtkTreeModel *model;
1058
1059 DB( g_print("\n[ui-import] page_transaction_update\n") );
1060
1061 ictx = &data->ictx;
1062
1063 gint pageidx = gtk_assistant_get_current_page(GTK_ASSISTANT(data->assistant));
1064 gint acckey = pageidx - (PAGE_IMPORT);
1065 //GenAcc *genacc = g_list_nth_data(ictx->gen_lst_acc, acckey);
1066 GenAcc *genacc = da_gen_acc_get_by_key(ictx->gen_lst_acc, acckey);
1067
1068 //txndata = &data->txndata[acckey];
1069 txndata = ui_import_page_transaction_data_get(data->txndata, acckey);
1070
1071 DB( g_print(" page idx:%d, genacckey:%d genacc:%p, txndata:%p\n", pageidx, acckey, genacc, txndata) );
1072
1073 if(genacc)
1074 {
1075 DB( g_print(" genacc id=%d name='%s'\n dstacc=%d\n", acckey, genacc->name, genacc->kacc ) );
1076
1077 visible = (genacc->is_unamed == TRUE) && (genacc->filetype != FILETYPE_CSV_HB) ? TRUE: FALSE;
1078 hb_widget_visible (txndata->IM_unamed, visible);
1079
1080 sensitive = (genacc->kacc == DST_ACC_SKIP) ? FALSE : TRUE;
1081 DB( g_print(" sensitive=%d\n", sensitive) );
1082
1083 gtk_widget_set_sensitive(txndata->LV_gentxn, sensitive);
1084 gtk_widget_set_sensitive(txndata->EX_duptxn, sensitive);
1085 //todo: disable option button
1086 gtk_widget_set_sensitive(txndata->GR_misc, sensitive);
1087 gtk_widget_set_sensitive(txndata->GR_date, sensitive);
1088 gtk_widget_set_sensitive(txndata->GR_ofx, sensitive);
1089 gtk_widget_set_sensitive(txndata->GR_qif, sensitive);
1090 gtk_widget_set_sensitive(txndata->GR_select, sensitive);
1091
1092 //todo: display a warning if incorrect date
1093 gchar *msg_icon = NULL, *msg_label = NULL;
1094
1095 iscomplete = (genacc->n_txnbaddate > 0) ? FALSE : TRUE;
1096 iscomplete = (genacc->kacc == DST_ACC_SKIP) ? TRUE : iscomplete;
1097
1098 DB( g_print(" nbbaddates=%d, dstacc=%d\n", genacc->n_txnbaddate, genacc->kacc) );
1099 DB( g_print(" iscomplete=%d\n", iscomplete) );
1100
1101 //show/hide invalid date group
1102 visible = FALSE;
1103 if(genacc->n_txnbaddate > 0)
1104 {
1105 visible = TRUE;
1106 DB( g_print(" invalid date detected\n" ) );
1107 msg_icon = ICONNAME_ERROR;
1108 msg_label =
1109 _("Some date cannot be converted. Please try to change the date order to continue.");
1110 }
1111 gtk_image_set_from_icon_name(GTK_IMAGE(txndata->IM_txn), msg_icon, GTK_ICON_SIZE_BUTTON);
1112 gtk_label_set_text(GTK_LABEL(txndata->LB_txn), msg_label);
1113 hb_widget_visible (txndata->GR_msg, visible);
1114
1115 //show/hide duplicate
1116 visible = TRUE;
1117 if( genacc->kacc==DST_ACC_GLOBAL || genacc->kacc==DST_ACC_NEW || genacc->kacc==DST_ACC_SKIP)
1118 visible = FALSE;
1119 hb_widget_visible (txndata->EX_duptxn, visible);
1120
1121 model = gtk_tree_view_get_model(GTK_TREE_VIEW(txndata->LV_gentxn));
1122
1123 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), LST_DSPOPE_DATE, GTK_SORT_ASCENDING);
1124 //gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
1125 //gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
1126
1127 GtkWidget *page = gtk_assistant_get_nth_page (GTK_ASSISTANT(data->assistant), pageidx);
1128 gtk_assistant_set_page_complete(GTK_ASSISTANT(data->assistant), page, iscomplete);
1129 }
1130
1131 }
1132
1133
1134 static void ui_import_page_transaction_cb_account_changed(GtkWidget *widget, gpointer user_data)
1135 {
1136 struct import_data *data;
1137 ImpTxnData *txndata;
1138 ImportContext *ictx;
1139 gint dstacc;
1140
1141 DB( g_print("\n[ui-import] cb_account_changed\n") );
1142
1143 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1144
1145 ictx = &data->ictx;
1146
1147 gint pageidx = gtk_assistant_get_current_page(GTK_ASSISTANT(data->assistant));
1148 gint acckey = pageidx - (PAGE_IMPORT);
1149 //GenAcc *genacc = g_list_nth_data(ictx->gen_lst_acc, accidx);
1150 GenAcc *genacc = da_gen_acc_get_by_key(ictx->gen_lst_acc, acckey);
1151
1152 //txndata = &data->txndata[acckey];
1153 txndata = ui_import_page_transaction_data_get(data->txndata, acckey);
1154
1155 dstacc = ui_genacc_comboboxtext_get_active (txndata->CY_acc);
1156 genacc->kacc = dstacc;
1157
1158 ui_import_page_transaction_options_get(data);
1159 hb_import_option_apply(ictx, genacc);
1160 hb_import_gen_txn_check_duplicate(ictx, genacc);
1161 hb_import_gen_txn_check_target_similar(ictx, genacc);
1162 genacc->is_dupcheck = TRUE;
1163
1164 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(txndata->LV_gentxn));
1165
1166 ui_import_page_transaction_update(data);
1167 }
1168
1169
1170 static void ui_import_page_transaction_cb_option_changed(GtkWidget *widget, gpointer user_data)
1171 {
1172 struct import_data *data;
1173 ImpTxnData *txndata;
1174 ImportContext *ictx;
1175
1176
1177 DB( g_print("\n[ui-import] cb_option_changed\n") );
1178
1179 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1180
1181 ictx = &data->ictx;
1182
1183 gint pageidx = gtk_assistant_get_current_page(GTK_ASSISTANT(data->assistant));
1184 gint acckey = pageidx - (PAGE_IMPORT);
1185 //GenAcc *genacc = g_list_nth_data(ictx->gen_lst_acc, accidx);
1186 GenAcc *genacc = da_gen_acc_get_by_key(ictx->gen_lst_acc, acckey);
1187
1188 //txndata = &data->txndata[acckey];
1189 txndata = ui_import_page_transaction_data_get(data->txndata, acckey);
1190
1191 ui_import_page_transaction_options_get(data);
1192 hb_import_option_apply(ictx, genacc);
1193
1194 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(txndata->LV_gentxn));
1195
1196 ui_import_page_transaction_update(data);
1197 }
1198
1199
1200 static void ui_import_page_transaction_fill(struct import_data *data)
1201 {
1202 ImpTxnData *txndata;
1203 ImportContext *ictx = &data->ictx;
1204 GtkWidget *view;
1205 GtkTreeModel *model;
1206 GtkTreeIter iter;
1207 GList *tmplist;
1208 gchar *label = NULL;
1209 gboolean visible;
1210 //gint nbacc;
1211
1212 DB( g_print("\n[ui-import] page_transaction_fill\n") );
1213
1214 //get the account, it will be the account into the glist
1215 //of pagenum - PAGE_IMPORT
1216 //gint pageidx = gtk_assistant_get_current_page(GTK_ASSISTANT(data->assistant));
1217 gint acckey = gtk_assistant_get_current_page(GTK_ASSISTANT(data->assistant)) - (PAGE_IMPORT);
1218 //GenAcc *genacc = g_list_nth_data(ictx->gen_lst_acc, acckey);
1219 GenAcc *genacc = da_gen_acc_get_by_key(ictx->gen_lst_acc, acckey);
1220 //nbacc = g_list_length(ictx->gen_lst_acc);
1221
1222 //txndata = &data->txndata[acckey];
1223 txndata = ui_import_page_transaction_data_get(data->txndata, acckey);
1224
1225 DB( g_print(" genacckey:%d genacc:%p, txndata:%p\n", acckey, genacc, txndata) );
1226
1227 if(genacc)
1228 {
1229 gint count;
1230
1231 DB( g_print(" genacc id=%d name='%s'\n dstacc=%d\n", acckey, genacc->name, genacc->kacc ) );
1232
1233 g_signal_handlers_block_by_func(txndata->CY_acc, G_CALLBACK(ui_import_page_transaction_cb_account_changed), NULL);
1234 ui_genacc_comboboxtext_set_active(txndata->CY_acc, genacc->kacc);
1235 g_signal_handlers_unblock_by_func(txndata->CY_acc, G_CALLBACK(ui_import_page_transaction_cb_account_changed), NULL);
1236
1237 ui_import_page_transaction_options_get(data);
1238 hb_import_option_apply(ictx, genacc);
1239 if( genacc->is_dupcheck == FALSE )
1240 {
1241 hb_import_gen_txn_check_duplicate(ictx, genacc);
1242 hb_import_gen_txn_check_target_similar(ictx, genacc);
1243 genacc->is_dupcheck = TRUE;
1244 }
1245
1246 view = txndata->LV_gentxn;
1247 model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
1248 gtk_list_store_clear (GTK_LIST_STORE(model));
1249
1250 count = 0;
1251 tmplist = g_list_first(ictx->gen_lst_txn);
1252 while (tmplist != NULL)
1253 {
1254 GenTxn *item = tmplist->data;
1255
1256 //todo: chnage this, this should be account
1257 if(item->kacc == genacc->key)
1258 {
1259 // append to our treeview
1260 //gtk_list_store_append (GTK_LIST_STORE(model), &iter);
1261 //gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1262 gtk_list_store_insert_with_values(GTK_LIST_STORE(model), &iter, -1,
1263 LST_GENTXN_POINTER, item,
1264 -1);
1265
1266 DB( g_print(" fill: %s, %d, %s %.2f\n", item->account, item->julian, item->memo, item->amount) );
1267 count++;
1268 }
1269 tmplist = g_list_next(tmplist);
1270 }
1271
1272 //label = g_strdup_printf(_("'%s' - %s"), genacc->name, hb_import_filetype_char_get(genacc));
1273 label = g_strdup_printf(_("Import <b>%s</b> in_to:"), genacc->is_unamed ? _("this file") : _("this account") );
1274 gtk_label_set_markup_with_mnemonic (GTK_LABEL(txndata->LB_acc_title), label);
1275 g_free(label);
1276
1277 //build tooltip
1278 GenFile *genfile = da_gen_file_get (ictx->gen_lst_file, genacc->kfile);
1279
1280 label = g_strdup_printf(_("Name: %s\nNumber: %s\nFile: %s\nEncoding: %s"), genacc->name, genacc->number, genfile->filepath, genfile->encoding);
1281 gtk_widget_set_tooltip_text (GTK_WIDGET(txndata->LB_acc_title), label);
1282 g_free(label);
1283
1284 //label = g_strdup_printf(_("Account %d of %d"), acckey+1, nbacc);
1285 //gtk_label_set_markup (GTK_LABEL(txndata->LB_acc_count), label);
1286 //g_free(label);
1287
1288 label = g_strdup_printf(_("%d transactions"), count);
1289 gtk_label_set_markup (GTK_LABEL(txndata->LB_txn_title), label);
1290 g_free(label);
1291
1292 visible = (genacc->filetype == FILETYPE_OFX) ? FALSE : TRUE;
1293 hb_widget_visible(GTK_WIDGET(txndata->GR_date), visible);
1294
1295 visible = (genacc->filetype == FILETYPE_OFX) ? TRUE : FALSE;
1296 hb_widget_visible(GTK_WIDGET(txndata->GR_ofx), visible);
1297
1298 visible = (genacc->filetype == FILETYPE_QIF) ? TRUE : FALSE;
1299 hb_widget_visible(GTK_WIDGET(txndata->GR_qif), visible);
1300
1301 gtk_stack_set_visible_child_name(GTK_STACK(txndata->ST_stack), visible ? "QIF" : "OFX");
1302
1303 }
1304
1305 }
1306
1307
1308
1309 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
1310
1311
1312 static void
1313 ui_import_page_intro_cb_dontshow(GtkWidget *widget, gpointer user_data)
1314 {
1315 PREFS->dtex_nointro = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget));
1316 }
1317
1318
1319 static GtkWidget *
1320 ui_import_page_intro_create(GtkWidget *assistant, struct import_data *data)
1321 {
1322 GtkWidget *mainbox, *label, *widget;
1323
1324
1325 mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
1326 gtk_widget_set_halign(mainbox, GTK_ALIGN_CENTER);
1327 gtk_widget_set_valign(mainbox, GTK_ALIGN_CENTER);
1328
1329
1330 label = make_label(_("Import transactions from bank or credit card"), 0, 0);
1331 gimp_label_set_attributes(GTK_LABEL(label),
1332 PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD,
1333 PANGO_ATTR_SCALE, PANGO_SCALE_LARGE,
1334 -1);
1335 gtk_box_pack_start (GTK_BOX (mainbox), label, FALSE, FALSE, SPACING_SMALL);
1336
1337 label = make_label(
1338 _("With this assistant you will be guided through the process of importing one or several\n" \
1339 "downloaded statements from your bank or credit card, in the following formats:"), 0, 0);
1340 gtk_box_pack_start (GTK_BOX (mainbox), label, FALSE, FALSE, SPACING_SMALL);
1341
1342 label = gtk_label_new(NULL);
1343 gtk_label_set_markup(GTK_LABEL(label),
1344 _("<b>Recommended:</b> .OFX or .QFX\n" \
1345 "<i>(Sometimes named Money™ or Quicken™)</i>\n" \
1346 "<b>Supported:</b> .QIF\n" \
1347 "<i>(Common Quicken™ file)</i>\n" \
1348 "<b>Advanced users only:</b> .CSV\n"
1349 "<i>(format is specific to HomeBank, see the documentation)</i>"));
1350
1351
1352 /* supported format */
1353 /*label = make_label(
1354 _("HomeBank can import files in the following formats:\n" \
1355 "- QIF\n" \
1356 "- OFX/QFX (optional at compilation time)\n" \
1357 "- CSV (format is specific to HomeBank, see the documentation)\n" \
1358 ), 0.0, 0.0);*/
1359
1360 gtk_box_pack_start (GTK_BOX (mainbox), label, FALSE, FALSE, SPACING_SMALL);
1361
1362
1363 label = make_label(
1364 _("No changes will be made until you click \"Apply\" at the end of this assistant."), 0., 0.0);
1365 gtk_box_pack_start (GTK_BOX (mainbox), label, FALSE, FALSE, SPACING_SMALL);
1366
1367
1368 widget = gtk_check_button_new_with_mnemonic (_("Don't show this again"));
1369 data->CM_dsta = widget;
1370 gtk_box_pack_end (GTK_BOX (mainbox), widget, FALSE, FALSE, SPACING_SMALL);
1371
1372 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(data->CM_dsta), PREFS->dtex_nointro);
1373
1374
1375 gtk_widget_show_all (mainbox);
1376
1377 g_signal_connect (data->CM_dsta, "toggled", G_CALLBACK (ui_import_page_intro_cb_dontshow), data);
1378
1379
1380 return mainbox;
1381 }
1382
1383
1384 static void ui_import_page_filechooser_update(GtkWidget *widget, gpointer user_data)
1385 {
1386 struct import_data *data;
1387 GtkTreeSelection *selection;
1388 gboolean sensitive;
1389
1390 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1391
1392 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_file));
1393
1394 gint count = gtk_tree_selection_count_selected_rows(selection);
1395
1396 sensitive = (count > 0) ? TRUE : FALSE;
1397 gtk_widget_set_sensitive(data->BT_file_remove, sensitive);
1398 //gtk_widget_set_sensitive(data->BT_merge, sensitive);
1399 //gtk_widget_set_sensitive(data->BT_delete, sensitive);
1400
1401 }
1402
1403
1404 static void ui_import_page_filechooser_selection(GtkTreeSelection *treeselection, gpointer user_data)
1405 {
1406 ui_import_page_filechooser_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
1407 }
1408
1409
1410 static GtkWidget *
1411 ui_import_page_filechooser_create (GtkWidget *assistant, struct import_data *data)
1412 {
1413 GtkWidget *mainbox, *vbox, *hbox, *widget, *label, *scrollwin, *tbar;
1414 GtkToolItem *toolitem;
1415
1416 mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
1417 //gtk_container_set_border_width (GTK_CONTAINER(vbox), SPACING_SMALL);
1418
1419 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1420 gtk_box_pack_start (GTK_BOX (mainbox), hbox, FALSE, FALSE, SPACING_SMALL);
1421
1422 widget = gtk_image_new_from_icon_name (ICONNAME_INFO, GTK_ICON_SIZE_LARGE_TOOLBAR);
1423 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, SPACING_SMALL);
1424
1425
1426 label = make_label(
1427 _("Drag&Drop one or several files to import.\n" \
1428 "You can also use the add/remove buttons of the list.")
1429 , 0., 0.0);
1430 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, SPACING_SMALL);
1431
1432
1433
1434
1435 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1436 gtk_box_pack_start (GTK_BOX (mainbox), vbox, TRUE, TRUE, 0);
1437
1438 //list
1439 scrollwin = gtk_scrolled_window_new (NULL, NULL);
1440 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1441 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1442 gtk_widget_set_hexpand(scrollwin, TRUE);
1443 gtk_widget_set_vexpand(scrollwin, TRUE);
1444 widget = list_file_new();
1445 data->LV_file = widget;
1446 gtk_container_add (GTK_CONTAINER (scrollwin), widget);
1447 //gtk_grid_attach (GTK_GRID (group_grid), scrollwin, 0, row, 2, 1);
1448 gtk_box_pack_start (GTK_BOX (vbox), scrollwin, TRUE, TRUE, 0);
1449
1450 //list toolbar
1451 tbar = gtk_toolbar_new();
1452 gtk_toolbar_set_icon_size (GTK_TOOLBAR(tbar), GTK_ICON_SIZE_MENU);
1453 gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_ICONS);
1454 gtk_style_context_add_class (gtk_widget_get_style_context (tbar), GTK_STYLE_CLASS_INLINE_TOOLBAR);
1455 gtk_box_pack_start (GTK_BOX (vbox), tbar, FALSE, FALSE, 0);
1456
1457 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1458 toolitem = gtk_tool_item_new();
1459 gtk_container_add (GTK_CONTAINER(toolitem), hbox);
1460 gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
1461
1462 widget = make_image_button(ICONNAME_LIST_ADD, NULL);
1463 data->BT_file_add = widget;
1464 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1465
1466 widget = make_image_button(ICONNAME_LIST_REMOVE, NULL);
1467 data->BT_file_remove = widget;
1468 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1469
1470
1471
1472
1473 gtk_widget_show_all (mainbox);
1474
1475 ui_import_page_filechooser_update(assistant, NULL);
1476
1477
1478 g_signal_connect (G_OBJECT (data->BT_file_add), "clicked", G_CALLBACK (ui_import_page_filechooser_add_action), data);
1479 g_signal_connect (G_OBJECT (data->BT_file_remove), "clicked", G_CALLBACK (ui_import_page_filechooser_remove_action), data);
1480
1481
1482 g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_file)), "changed", G_CALLBACK (ui_import_page_filechooser_selection), NULL);
1483
1484
1485 return mainbox;
1486 }
1487
1488
1489 static GtkWidget *
1490 ui_import_page_import_create (GtkWidget *assistant, struct import_data *data)
1491 {
1492 GtkWidget *mainbox;
1493 GtkWidget *label, *widget;
1494 gchar *txt;
1495
1496 mainbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1497 //gtk_widget_set_halign(mainbox, GTK_ALIGN_CENTER);
1498 //gtk_widget_set_valign(mainbox, GTK_ALIGN_CENTER);
1499
1500 widget = gtk_image_new_from_icon_name(ICONNAME_ERROR, GTK_ICON_SIZE_DIALOG );
1501 gtk_box_pack_start (GTK_BOX (mainbox), widget, FALSE, FALSE, 0);
1502
1503 txt = _("There is too much account in the files you choosed,\n" \
1504 "please use the back button to select less files.");
1505 label = gtk_label_new(txt);
1506 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
1507 gtk_box_pack_start (GTK_BOX (mainbox), label, FALSE, FALSE, 0);
1508
1509 gtk_widget_show_all (mainbox);
1510
1511 return mainbox;
1512 }
1513
1514
1515
1516
1517 static gboolean
1518 ui_import_page_transaction_cb_activate_link (GtkWidget *label, const gchar *uri, gpointer user_data)
1519 {
1520 GtkTreeModel *model;
1521 GtkTreeIter iter;
1522 gboolean valid;
1523 GenTxn *gentxn;
1524
1525 g_return_val_if_fail(GTK_IS_TREE_VIEW(user_data), TRUE);
1526
1527 model = gtk_tree_view_get_model(GTK_TREE_VIEW(user_data));
1528
1529 DB( g_print(" comboboxlink '%s' \n", uri) );
1530
1531 if (g_strcmp0 (uri, "all") == 0)
1532 {
1533 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
1534 while (valid)
1535 {
1536 gtk_tree_model_get(model, &iter,
1537 LST_GENTXN_POINTER, &gentxn,
1538 -1);
1539
1540 gentxn->to_import = TRUE;
1541 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
1542 }
1543 }
1544 else
1545 if (g_strcmp0 (uri, "non") == 0)
1546 {
1547 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
1548 while (valid)
1549 {
1550 gtk_tree_model_get(model, &iter,
1551 LST_GENTXN_POINTER, &gentxn,
1552 -1);
1553
1554 gentxn->to_import = FALSE;
1555 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
1556 }
1557 }
1558 else
1559 if (g_strcmp0 (uri, "inv") == 0)
1560 {
1561 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
1562 while (valid)
1563 {
1564 gtk_tree_model_get(model, &iter,
1565 LST_GENTXN_POINTER, &gentxn,
1566 -1);
1567
1568 gentxn->to_import ^= TRUE;
1569 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
1570 }
1571 }
1572
1573 gtk_widget_queue_draw(GTK_WIDGET(user_data));
1574
1575 return TRUE;
1576 }
1577
1578
1579 static GtkWidget *
1580 ui_import_page_transaction_create (GtkWidget *assistant, gint idx, struct import_data *data)
1581 {
1582 ImpTxnData *txndata;
1583 GtkWidget *table, *box, *group, *stack;
1584 GtkWidget *label, *scrollwin, *expander, *widget;
1585 ImpTxnData tmp;
1586 gint row;
1587
1588 //txndata = &data->txndata[idx];
1589 memset(&tmp, 0, sizeof(ImpTxnData));
1590 g_array_insert_vals(data->txndata, idx, &tmp, 1);
1591
1592 txndata = ui_import_page_transaction_data_get(data->txndata, idx);
1593
1594 DB( g_print(" txndat=%p\n", txndata) );
1595
1596 if(!txndata)
1597 return NULL;
1598
1599 table = gtk_grid_new ();
1600 gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_SMALL);
1601 gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
1602
1603 row = 0;
1604 //line 1 left
1605 box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1606 //gtk_widget_set_hexpand(box, TRUE);
1607 gtk_grid_attach (GTK_GRID(table), box, 0, row, 1, 1);
1608
1609 // XXX (type) + accname
1610 label = make_label(NULL, 0.0, 0.5);
1611 txndata->LB_acc_title = label;
1612 //gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_LARGE, -1);
1613 gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
1614
1615 widget = ui_genacc_comboboxtext_new(data, label);
1616 //gtk_widget_set_hexpand(widget, TRUE);
1617 txndata->CY_acc = widget;
1618 gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
1619
1620 widget = gtk_image_new_from_icon_name(ICONNAME_WARNING, GTK_ICON_SIZE_SMALL_TOOLBAR);
1621 txndata->IM_unamed = widget;
1622 gtk_widget_set_tooltip_text (widget, _("Target account identification by name or number failed."));
1623 gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
1624
1625 //line 1 right
1626 box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1627 //gtk_widget_set_hexpand(box, TRUE);
1628 gtk_grid_attach (GTK_GRID(table), box, 1, row, 1, 1);
1629
1630 //csv options
1631 group = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1632 txndata->GR_date = group;
1633 gtk_box_pack_start (GTK_BOX(box), group, FALSE, FALSE, 0);
1634
1635 label = make_label(_("Date order:"), 0, 0.5);
1636 gtk_box_pack_start (GTK_BOX(group), label, FALSE, FALSE, 0);
1637 widget = make_cycle(label, CYA_IMPORT_DATEORDER);
1638 txndata->CY_txn_dateorder = widget;
1639 gtk_box_pack_start (GTK_BOX(group), widget, FALSE, FALSE, 0);
1640
1641 stack = gtk_stack_new();
1642 gtk_box_pack_start (GTK_BOX(box), stack, FALSE, FALSE, 0);
1643 txndata->ST_stack= stack;
1644
1645 //qif options
1646 group = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1647 txndata->GR_qif = group;
1648 //gtk_box_pack_start (GTK_BOX(box), group, FALSE, FALSE, 0);
1649 gtk_stack_add_named(GTK_STACK(stack), group, "QIF");
1650
1651 widget = gtk_check_button_new_with_mnemonic (_("_Import memos"));
1652 txndata->CM_txn_qifmemo = widget;
1653 gtk_box_pack_start (GTK_BOX(group), widget, FALSE, FALSE, 0);
1654
1655 widget = gtk_check_button_new_with_mnemonic (_("_Swap memos with payees"));
1656 txndata->CM_txn_qifswap = widget;
1657 gtk_box_pack_start (GTK_BOX(group), widget, FALSE, FALSE, 0);
1658
1659 //ofx options
1660 group = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1661 txndata->GR_ofx = group;
1662 //gtk_box_pack_start (GTK_BOX(box), group, FALSE, FALSE, 0);
1663 gtk_stack_add_named(GTK_STACK(stack), group, "OFX");
1664
1665 label = make_label(_("OFX _Name:"), 0, 0.5);
1666 gtk_box_pack_start (GTK_BOX(group), label, FALSE, FALSE, 0);
1667 widget = make_cycle(label, CYA_IMPORT_OFXNAME);
1668 txndata->CY_txn_ofxname = widget;
1669 gtk_box_pack_start (GTK_BOX(group), widget, FALSE, FALSE, 0);
1670
1671 label = make_label(_("OFX _Memo:"), 0, 0.5);
1672 gtk_box_pack_start (GTK_BOX(group), label, FALSE, FALSE, 0);
1673 widget = make_cycle(label, CYA_IMPORT_OFXMEMO);
1674 txndata->CY_txn_ofxmemo = widget;
1675 gtk_box_pack_start (GTK_BOX(group), widget, FALSE, FALSE, 0);
1676
1677 // n transaction ...
1678 row++;
1679 box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1680 //gtk_widget_set_hexpand(box, TRUE);
1681 gtk_grid_attach (GTK_GRID(table), box, 0, row, 1, 1);
1682
1683 group = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1684 txndata->GR_select = group;
1685 gtk_box_pack_start (GTK_BOX (box), group, FALSE, FALSE, 0);
1686
1687 label = make_label (_("Select:"), 0, 0.5);
1688 gtk_box_pack_start (GTK_BOX (group), label, FALSE, FALSE, 0);
1689
1690 label = make_clicklabel("all", _("All"));
1691 txndata->BT_all= label;
1692 gtk_box_pack_start (GTK_BOX (group), label, FALSE, FALSE, 0);
1693
1694 label = make_clicklabel("non", _("None"));
1695 txndata->BT_non = label;
1696 gtk_box_pack_start (GTK_BOX (group), label, FALSE, FALSE, 0);
1697
1698 label = make_clicklabel("inv", _("Invert"));
1699 txndata->BT_inv = label;
1700 gtk_box_pack_start (GTK_BOX (group), label, FALSE, FALSE, 0);
1701
1702 label = make_label(NULL, 0.0, 0.0);
1703 txndata->LB_txn_title = label;
1704 gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
1705 gtk_box_pack_start (GTK_BOX (group), label, FALSE, FALSE, 0);
1706
1707 // import into
1708 box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1709 gtk_grid_attach (GTK_GRID(table), box, 1, row, 1, 1);
1710
1711 group = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1712 txndata->GR_misc = group;
1713 gtk_box_pack_start (GTK_BOX (box), group, FALSE, FALSE, 0);
1714
1715 widget = gtk_check_button_new_with_mnemonic (_("Sentence _case memo/payee"));
1716 txndata->CM_txn_ucfirst = widget;
1717 gtk_box_pack_start (GTK_BOX(group), widget, FALSE, FALSE, 0);
1718
1719
1720 // error messages
1721 row++;
1722 box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1723 txndata->GR_msg = box;
1724 //gtk_widget_set_hexpand(box, TRUE);
1725 gtk_grid_attach (GTK_GRID(table), box, 0, row, 2, 1);
1726
1727 widget = gtk_image_new ();
1728 txndata->IM_txn = widget;
1729 gtk_widget_set_valign(widget, GTK_ALIGN_START);
1730 gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
1731 label = make_label(NULL, 0.0, 0.5);
1732 txndata->LB_txn = label;
1733 gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
1734
1735 row++;
1736 scrollwin = gtk_scrolled_window_new (NULL, NULL);
1737 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1738 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1739 widget = list_txn_import_create();
1740 txndata->LV_gentxn = widget;
1741 gtk_widget_set_hexpand(scrollwin, TRUE);
1742 gtk_widget_set_vexpand(scrollwin, TRUE);
1743 gtk_container_add (GTK_CONTAINER (scrollwin), widget);
1744 gtk_grid_attach (GTK_GRID(table), scrollwin, 0, row, 2, 1);
1745
1746
1747 //duplicate
1748 row++;
1749 expander = gtk_expander_new (_("Similar transaction in target account (possible duplicate)"));
1750 txndata->EX_duptxn = expander;
1751 //gtk_widget_set_hexpand(expander, TRUE);
1752 gtk_grid_attach (GTK_GRID(table), expander, 0, row, 2, 1);
1753
1754
1755 group = gtk_grid_new ();
1756 gtk_grid_set_row_spacing (GTK_GRID (group), SPACING_SMALL);
1757 gtk_grid_set_column_spacing (GTK_GRID (group), SPACING_SMALL);
1758 gtk_container_add (GTK_CONTAINER (expander), group);
1759
1760 row = 0;
1761 scrollwin = gtk_scrolled_window_new (NULL, NULL);
1762 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1763 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1764 gtk_widget_set_hexpand(scrollwin, TRUE);
1765 //widget = create_list_transaction(LIST_TXN_TYPE_DETAIL, PREFS->lst_ope_columns);
1766 widget = create_list_transaction(LIST_TXN_TYPE_DETAIL, PREFS->lst_impope_columns);
1767 txndata->LV_duptxn = widget;
1768 gtk_container_add (GTK_CONTAINER (scrollwin), widget);
1769 gtk_widget_set_size_request(scrollwin, -1, HB_MINWIDTH_LIST/2);
1770 gtk_grid_attach (GTK_GRID (group), scrollwin, 0, row, 5, 1);
1771
1772 row++;
1773 label = make_label(_("Date _gap:"), 0, 0.5);
1774 gtk_grid_attach (GTK_GRID (group), label, 0, row, 1, 1);
1775
1776 widget = make_numeric(label, 0.0, HB_DATE_MAX_GAP);
1777 txndata->NB_txn_daygap = widget;
1778 gtk_grid_attach (GTK_GRID (group), widget, 1, row, 1, 1);
1779
1780 //TRANSLATORS: there is a spinner on the left of this label, and so you have 0....x days of date tolerance
1781 label = make_label(_("days"), 0, 0.5);
1782 gtk_grid_attach (GTK_GRID (group), label, 2, row, 1, 1);
1783
1784 widget = gtk_image_new_from_icon_name(ICONNAME_INFO, GTK_ICON_SIZE_SMALL_TOOLBAR );
1785 gtk_widget_set_hexpand(widget, FALSE);
1786 gtk_grid_attach (GTK_GRID (group), widget, 3, row, 1, 1);
1787
1788 label = make_label (_(
1789 "The match is done in order: by account, amount and date.\n" \
1790 "A date tolerance of 0 day means an exact match"), 0, 0.5);
1791 gimp_label_set_attributes (GTK_LABEL (label),
1792 PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
1793 -1);
1794 gtk_widget_set_hexpand(label, TRUE);
1795 gtk_grid_attach (GTK_GRID (group), label, 4, row, 1, 1);
1796
1797
1798 // init ofx/qfx option to move
1799 gtk_combo_box_set_active(GTK_COMBO_BOX(txndata->CY_txn_dateorder), PREFS->dtex_datefmt);
1800 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(txndata->CM_txn_ucfirst), PREFS->dtex_ucfirst);
1801
1802 gtk_combo_box_set_active(GTK_COMBO_BOX(txndata->CY_txn_ofxname), PREFS->dtex_ofxname);
1803 gtk_combo_box_set_active(GTK_COMBO_BOX(txndata->CY_txn_ofxmemo), PREFS->dtex_ofxmemo);
1804
1805 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(txndata->CM_txn_qifmemo), PREFS->dtex_qifmemo);
1806 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(txndata->CM_txn_qifswap), PREFS->dtex_qifswap);
1807
1808 gtk_widget_show_all (table);
1809 gtk_widget_hide(txndata->GR_qif);
1810 gtk_widget_hide(txndata->GR_ofx);
1811
1812 g_signal_connect (txndata->BT_all, "activate-link", G_CALLBACK (ui_import_page_transaction_cb_activate_link), txndata->LV_gentxn);
1813 g_signal_connect (txndata->BT_non, "activate-link", G_CALLBACK (ui_import_page_transaction_cb_activate_link), txndata->LV_gentxn);
1814 g_signal_connect (txndata->BT_inv, "activate-link", G_CALLBACK (ui_import_page_transaction_cb_activate_link), txndata->LV_gentxn);
1815
1816 g_signal_connect (txndata->CY_acc , "changed", G_CALLBACK (ui_import_page_transaction_cb_account_changed), data);
1817 g_signal_connect (txndata->CY_txn_dateorder, "changed", G_CALLBACK (ui_import_page_transaction_cb_account_changed), data);
1818 g_signal_connect (txndata->NB_txn_daygap , "value-changed", G_CALLBACK (ui_import_page_transaction_cb_account_changed), data);
1819
1820 g_signal_connect (txndata->CY_txn_ofxname , "changed", G_CALLBACK (ui_import_page_transaction_cb_option_changed), data);
1821 g_signal_connect (txndata->CY_txn_ofxmemo , "changed", G_CALLBACK (ui_import_page_transaction_cb_option_changed), data);
1822 g_signal_connect (txndata->CM_txn_qifmemo, "toggled", G_CALLBACK (ui_import_page_transaction_cb_option_changed), data);
1823 g_signal_connect (txndata->CM_txn_qifswap, "toggled", G_CALLBACK (ui_import_page_transaction_cb_option_changed), data);
1824 g_signal_connect (txndata->CM_txn_ucfirst, "toggled", G_CALLBACK (ui_import_page_transaction_cb_option_changed), data);
1825
1826 g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(txndata->LV_gentxn)), "changed",
1827 G_CALLBACK (ui_import_page_transaction_cb_fill_same), NULL);
1828
1829 return table;
1830 }
1831
1832
1833 static GtkWidget *
1834 ui_import_page_confirmation_create(GtkWidget *assistant, struct import_data *data)
1835 {
1836 GtkWidget *mainbox, *label, *widget, *scrollwin;
1837
1838 mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
1839 //gtk_container_set_border_width (GTK_CONTAINER(mainbox), SPACING_SMALL);
1840
1841 scrollwin = gtk_scrolled_window_new (NULL, NULL);
1842 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_NONE);
1843 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1844 gtk_widget_set_hexpand(scrollwin, TRUE);
1845 gtk_widget_set_vexpand(scrollwin, TRUE);
1846 widget = gtk_label_new (NULL);
1847 data->TX_summary = widget;
1848 gtk_container_add (GTK_CONTAINER (scrollwin), widget);
1849 gtk_box_pack_start (GTK_BOX (mainbox), scrollwin, TRUE, TRUE, 0);
1850
1851 label = make_label(
1852 _("Click \"Apply\" to update your accounts.\n"), 0.5, 0.5);
1853 gtk_box_pack_start (GTK_BOX (mainbox), label, FALSE, FALSE, 0);
1854
1855 gtk_widget_set_margin_top(GTK_WIDGET(label), SPACING_SMALL);
1856 gtk_widget_set_margin_bottom(GTK_WIDGET(label), SPACING_SMALL);
1857
1858 gtk_widget_show_all (mainbox);
1859
1860 return mainbox;
1861 }
1862
1863
1864
1865 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
1866 /**
1867 * ui_import_assistant_forward_page_func:
1868 *
1869 * define the page to be called when the user forward
1870 *
1871 * Return value: the page number
1872 *
1873 */
1874
1875 /*static gint
1876 ui_import_assistant_forward_page_func(gint current_page, gpointer func_data)
1877 {
1878 struct import_data *data;
1879 GtkWidget *page;
1880 gint next_page;
1881
1882 data = func_data;
1883
1884 DB( g_print("---------------------------\n") );
1885 DB( g_print("\n[ui-import] forward page func\n") );
1886
1887 page = gtk_assistant_get_nth_page(GTK_ASSISTANT(data->assistant), current_page);
1888
1889 DB( g_print(" -> current: %d %s\n", current_page, gtk_assistant_get_page_title(GTK_ASSISTANT(data->assistant), page) ) );
1890
1891 #if MYDEBUG == 1
1892
1893 struct import_data *data = func_data;
1894 gint i
1895 for(i=0;i<NUM_PAGE;i++)
1896 {
1897 g_print("%d: %d '%s'\n", i,
1898 gtk_assistant_get_page_complete(GTK_ASSISTANT(data->assistant), data->pages[i]),
1899 page_titles[i]
1900 );
1901 #endif
1902
1903 next_page = current_page + 1;
1904
1905 switch(current_page)
1906 {
1907 //case PAGE_IMPORT:
1908 // if no new account, skip the account page
1909 //if(ictx->nb_new_acc == 0)
1910 // next_page = PAGE_TRANSACTION;
1911 //break;
1912 }
1913
1914 page = gtk_assistant_get_nth_page(GTK_ASSISTANT(data->assistant), next_page);
1915 DB( g_print(" -> next: %d %s\n", next_page, gtk_assistant_get_page_title(GTK_ASSISTANT(data->assistant), page) ) );
1916
1917 return next_page;
1918 }*/
1919
1920
1921 static void
1922 ui_import_assistant_prepare (GtkWidget *widget, GtkWidget *page, gpointer user_data)
1923 {
1924 struct import_data *data;
1925 ImportContext *ictx;
1926 gint current_page, n_pages;
1927
1928 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1929
1930 ictx = &data->ictx;
1931
1932 current_page = gtk_assistant_get_current_page (GTK_ASSISTANT(data->assistant));
1933 n_pages = gtk_assistant_get_n_pages (GTK_ASSISTANT(data->assistant));
1934
1935 DB( g_print("\n--------\n[ui-import] prepare \n page %d of %d\n", current_page, n_pages) );
1936
1937 switch( current_page )
1938 {
1939 case PAGE_WELCOME:
1940 DB( g_print("\n #1 intro\n") );
1941 gtk_assistant_set_page_complete (GTK_ASSISTANT(data->assistant), page, TRUE);
1942 break;
1943
1944 case PAGE_FILES:
1945 DB( g_print("\n #2 file choose\n") );
1946 gtk_assistant_set_page_complete (GTK_ASSISTANT(data->assistant), page, FALSE);
1947
1948 //open the file add if no file
1949 if( gtk_tree_model_iter_n_children(gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_file)), NULL) == 0 )
1950 {
1951 //g_signal_emit_by_name(data->BT_file_add, "clicked", NULL);
1952 ui_import_page_filechooser_add_action(data->BT_file_add, NULL);
1953 }
1954
1955 // the page complete is contextual in ui_import_page_filechooser_selection_changed
1956 // check is something valid :: count total rows
1957 ui_import_page_filechooser_eval(widget, user_data);
1958 break;
1959
1960 case PAGE_IMPORT:
1961 DB( g_print("\n #3 real import\n") );
1962 gtk_assistant_set_page_complete (GTK_ASSISTANT(data->assistant), page, FALSE);
1963
1964 //todo: more test needed here
1965 //clean any previous txn page
1966 /*for(i=(n_pages-1);i>=PAGE_IMPORT+1;i--)
1967 {
1968 GtkWidget *page = gtk_assistant_get_nth_page (GTK_ASSISTANT(data->assistant), i);
1969 gboolean isacc;
1970
1971 if( page != NULL )
1972 {
1973 isacc = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(page), "pgacc"));
1974
1975 DB( g_print(" %d is acc: %d\n", i, isacc) );
1976
1977 if( isacc )
1978 {
1979 gtk_assistant_remove_page(GTK_ASSISTANT(data->assistant), i);
1980 gtk_widget_destroy (page);
1981 }
1982 }
1983 }*/
1984
1985 hb_import_load_all(&data->ictx);
1986
1987 //add 1 page per account
1988 gint key, nbacc;
1989 nbacc = g_list_length (ictx->gen_lst_acc);
1990
1991 if(data->txndata)
1992 {
1993 g_array_free(data->txndata, TRUE);
1994 data->txndata = NULL;
1995 }
1996 data->txndata = g_array_sized_new(FALSE, TRUE, sizeof(ImpTxnData), nbacc);
1997
1998 //#1820618 patch for glib < 2.58 https://gitlab.gnome.org/GNOME/glib/issues/1374
1999 if( glib_minor_version < 58 )
2000 {
2001 g_array_set_size(data->txndata, nbacc);
2002 }
2003
2004 DB( g_print(" accnb=%d @%p\n", nbacc, data->txndata) );
2005
2006 //debug
2007 //_import_context_debug_acc_list(&data->ictx);
2008
2009 //if(nbacc < TXN_MAX_ACCOUNT)
2010 //{
2011 for(key=1;key<nbacc+1;key++)
2012 {
2013 GtkWidget *page;
2014 GenAcc *genacc;
2015 gchar *title;
2016
2017 genacc = da_gen_acc_get_by_key(ictx->gen_lst_acc, key);
2018
2019 DB( g_print(" create page txn for '%s' '%s' at page %d\n", genacc->name, genacc->number, PAGE_IMPORT + key) );
2020
2021 page = ui_import_page_transaction_create (data->assistant, key, data);
2022 //g_object_set_data(G_OBJECT(page), "pgacc", (gpointer)TRUE);
2023 gtk_widget_show_all (page);
2024 gtk_assistant_insert_page (GTK_ASSISTANT (data->assistant), page, PAGE_IMPORT + key);
2025 //gtk_assistant_set_page_title (GTK_ASSISTANT (data->assistant), page, _("Transaction"));
2026 //gtk_assistant_set_page_title (GTK_ASSISTANT (data->assistant), page, genacc->name);
2027
2028 title = g_strdup_printf("%s %d", (!genacc->is_unamed) ? _("Account") : _("Unknown"), key );
2029 gtk_assistant_set_page_title (GTK_ASSISTANT (data->assistant), page, title);
2030 g_free(title);
2031 }
2032 //}
2033
2034 // obsolete ??
2035 if( ui_import_page_import_eval (widget, NULL) )
2036 {
2037 /*if(ictx->nb_new_acc == 0)
2038 {
2039 DB( g_print(" -> jump to Transaction page\n") );
2040 //gtk_assistant_set_page_complete (GTK_ASSISTANT(data->assistant), data->pages[PAGE_ACCOUNT], TRUE);
2041 gtk_assistant_next_page(GTK_ASSISTANT(data->assistant));
2042 gtk_assistant_next_page(GTK_ASSISTANT(data->assistant));
2043 //gtk_assistant_set_current_page (GTK_ASSISTANT(data->assistant), PAGE_TRANSACTION);
2044 }
2045 else
2046 {
2047 DB( g_print(" -> jump to Account page\n") );
2048 //gtk_assistant_set_current_page (GTK_ASSISTANT(data->assistant), PAGE_ACCOUNT);
2049 gtk_assistant_next_page(GTK_ASSISTANT(data->assistant));
2050 }*/
2051
2052 gtk_assistant_next_page(GTK_ASSISTANT(data->assistant));
2053 gtk_assistant_set_page_complete (GTK_ASSISTANT(data->assistant), page, TRUE);
2054 }
2055 break;
2056
2057 default:
2058 if(current_page != (n_pages - 1))
2059 {
2060 DB( g_print("\n #4 transaction\n") );
2061
2062 if( current_page == PAGE_IMPORT + 1)
2063 //hack to get rid of back button
2064 gtk_assistant_set_page_type (GTK_ASSISTANT(data->assistant), page, GTK_ASSISTANT_PAGE_INTRO);
2065
2066 ui_import_page_transaction_fill(data);
2067 ui_import_page_transaction_update(data);
2068 }
2069 else
2070 {
2071 DB( g_print("\n #5 confirmation\n") );
2072
2073 //todo: auto assignment should be optional
2074 //data->imp_cnt_asg = transaction_auto_assign(ictx->trans_list, 0);
2075 //ui_import_page_transaction_find_duplicate(data);
2076
2077 ui_import_page_confirmation_fill(data);
2078 gtk_assistant_set_page_complete (GTK_ASSISTANT(data->assistant), page, TRUE);
2079 }
2080 }
2081 }
2082
2083
2084 static void
2085 ui_import_assistant_apply (GtkWidget *widget, gpointer user_data)
2086 {
2087 struct import_data *data;
2088
2089 DB( g_print("\n[ui-import] apply\n") );
2090
2091 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
2092
2093 hb_import_apply(&data->ictx);
2094 }
2095
2096
2097 static gboolean
2098 ui_import_assistant_dispose(GtkWidget *widget, gpointer user_data)
2099 {
2100 struct import_data *data = user_data;
2101
2102 DB( g_print("\n[ui-import] dispose\n") );
2103
2104 #if MYDEBUG == 1
2105 gpointer data2 = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
2106 g_print(" user_data=%p to be free, data2=%p\n", user_data, data2);
2107 #endif
2108
2109 da_import_context_destroy(&data->ictx);
2110
2111 if(data->txndata)
2112 {
2113 g_array_free(data->txndata, TRUE);
2114 }
2115
2116
2117 // todo: optimize this
2118 //if(data->imp_cnt_trn > 0)
2119 //{
2120 //GLOBALS->changes_count += data->imp_cnt_trn;
2121
2122 //our global list has changed, so update the treeview
2123 ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_TITLE+UF_SENSITIVE+UF_BALANCE+UF_REFRESHALL));
2124 //}
2125
2126 g_free(user_data);
2127
2128 //delete-event TRUE abort/FALSE destroy
2129 return FALSE;
2130 }
2131
2132
2133 static void
2134 ui_import_assistant_close_cancel (GtkWidget *widget, gpointer user_data)
2135 {
2136 struct import_data *data;
2137 GtkWidget *assistant = (GtkWidget *) user_data;
2138
2139 DB( g_print("\n[ui-import] close\n") );
2140
2141 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
2142
2143 ui_import_assistant_dispose(widget, data);
2144 gtk_widget_destroy (assistant);
2145 }
2146
2147
2148 /* starting point of import */
2149 GtkWidget *ui_import_assistant_new (gchar **paths)
2150 {
2151 struct import_data *data;
2152 GtkWidget *assistant, *page;
2153 gint w, h;
2154
2155 DB( g_print("\n[ui-import] new\n") );
2156
2157 data = g_malloc0(sizeof(struct import_data));
2158 if(!data) return NULL;
2159
2160 assistant = gtk_assistant_new ();
2161 data->assistant = assistant;
2162
2163 //store our window private data
2164 g_object_set_data(G_OBJECT(assistant), "inst_data", (gpointer)data);
2165 //DB( g_print("** \n[ui-import] window=%x, inst_data=%x\n", assistant, data) );
2166
2167 gtk_window_set_modal(GTK_WINDOW (assistant), TRUE);
2168 gtk_window_set_transient_for(GTK_WINDOW(assistant), GTK_WINDOW(GLOBALS->mainwindow));
2169
2170 //set a nice dialog size
2171 gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
2172 gtk_window_set_default_size (GTK_WINDOW(assistant), w * 0.8, h * 0.8);
2173 //gtk_window_set_default_size (GTK_WINDOW(assistant), w - 24, h - 24);
2174
2175 page = ui_import_page_intro_create (assistant, data);
2176 gtk_assistant_append_page (GTK_ASSISTANT (assistant), page);
2177 gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), page, GTK_ASSISTANT_PAGE_INTRO);
2178 gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), page, _("Welcome"));
2179 gtk_assistant_set_page_complete (GTK_ASSISTANT(assistant), page, TRUE );
2180
2181 page = ui_import_page_filechooser_create (assistant, data);
2182 gtk_assistant_append_page (GTK_ASSISTANT (assistant), page);
2183 gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), page, _("Select file(s)"));
2184
2185 page = ui_import_page_import_create (assistant, data);
2186 gtk_assistant_append_page (GTK_ASSISTANT (assistant), page);
2187 //gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), page, GTK_ASSISTANT_PAGE_PROGRESS);
2188 gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), page, _("Import"));
2189
2190 //3...x transaction page will be added automatically
2191
2192 //page = ui_import_page_transaction_create (assistant, 0, data);
2193 //gtk_assistant_append_page (GTK_ASSISTANT (assistant), page);
2194 //hack to hide the back button here
2195 //gtk_assistant_set_page_type (GTK_ASSISTANT(assistant), page, GTK_ASSISTANT_PAGE_INTRO);
2196 //gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), page, _("Transaction"));
2197
2198 page = ui_import_page_confirmation_create (assistant, data);
2199 gtk_assistant_append_page (GTK_ASSISTANT (assistant), page);
2200 gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), page, GTK_ASSISTANT_PAGE_CONFIRM);
2201 gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), page, _("Confirmation"));
2202
2203 //gtk_assistant_set_forward_page_func(GTK_ASSISTANT(assistant), ui_import_assistant_forward_page_func, data, NULL);
2204
2205 //setup
2206 //ui_import_page_filechooser_selection_changed(assistant, data);
2207 DB( g_printf(" check list of paths '%p'\n", paths) );
2208 if( paths != NULL )
2209 {
2210 ImportContext *ictx = &data->ictx;
2211 GenFile *genfile;
2212 gchar **str = paths;
2213
2214 while(*str != NULL)
2215 {
2216 DB( g_printf(" try to append '%s'\n", *str) );
2217
2218 genfile = da_gen_file_append_from_filename(ictx, *str);
2219 if(genfile)
2220 {
2221 list_file_add(data->LV_file, genfile);
2222 }
2223 str++;
2224 }
2225 g_strfreev(paths);
2226 }
2227
2228 //connect all our signals
2229 //g_signal_connect (window, "delete-event", G_CALLBACK (hbfile_dispose), (gpointer)data);
2230 g_signal_connect (G_OBJECT (assistant), "cancel", G_CALLBACK (ui_import_assistant_close_cancel), assistant);
2231 g_signal_connect (G_OBJECT (assistant), "close", G_CALLBACK (ui_import_assistant_close_cancel), assistant);
2232 g_signal_connect (G_OBJECT (assistant), "apply", G_CALLBACK (ui_import_assistant_apply), NULL);
2233 g_signal_connect (G_OBJECT (assistant), "prepare", G_CALLBACK (ui_import_assistant_prepare), NULL);
2234
2235 gtk_widget_show (assistant);
2236
2237 if(PREFS->dtex_nointro)
2238 gtk_assistant_set_current_page(GTK_ASSISTANT(assistant), PAGE_FILES);
2239
2240 return assistant;
2241 }
2242
fork of homebank with support for plugins
This page took 0.130711 seconds and 4 git commands to generate.