← Back to branch summary

~mdoyen/homebank/5.2.x

« back to all changes in this revision

Viewing changes to src/dsp-mainwindow.c

  • Committer: Maxime Doyen
  • Date: 2019-04-11 20:36:11 UTC
  • Revision ID: homebank@free.fr-20190411203611-pby791lywld1op5a
5.2.4 release

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dsp-mainwindow.c
23
23
#include "dsp-mainwindow.h"
24
24
 
25
25
#include "list-account.h"
26
 
#include "list-upcoming.h"
27
 
#include "list-topspending.h"
 
26
 
 
27
#include "hub-account.h"
 
28
#include "hub-scheduled.h"
 
29
#include "hub-spending.h"
 
30
#include "hub-transaction.h"
28
31
 
29
32
#include "dsp-account.h"
30
33
#include "ui-assist-import.h"
134
137
 
135
138
static GtkWidget *ui_mainwindow_create_recent_chooser_menu (GtkRecentManager *manager);
136
139
 
137
 
static void ui_mainwindow_populate_topspending(GtkWidget *widget, gpointer user_data);
138
 
 
139
140
void ui_mainwindow_open(GtkWidget *widget, gpointer user_data);
140
141
 
141
142
void ui_mainwindow_save(GtkWidget *widget, gpointer user_data);
144
145
void ui_mainwindow_toggle_minor(GtkWidget *widget, gpointer user_data);
145
146
void ui_mainwindow_clear(GtkWidget *widget, gpointer user_data);
146
147
 
147
 
gboolean ui_dialog_msg_savechanges(GtkWidget *widget, gpointer user_data);
148
 
 
149
148
void ui_mainwindow_update(GtkWidget *widget, gpointer user_data);
150
149
void ui_mainwindow_addtransactions(GtkWidget *widget, gpointer user_data);
151
150
void ui_mainwindow_recent_add (struct hbfile_data *data, const gchar *path);
152
151
 
153
 
static void ui_panel_topspending_update(GtkWidget *widget, gpointer user_data);
154
 
 
155
 
static void ui_mainwindow_scheduled_populate(GtkWidget *widget, gpointer user_data);
156
 
void ui_mainwindow_scheduled_postall(GtkWidget *widget, gpointer user_data);
157
 
 
158
152
void ui_mainwindow_recent_add (struct hbfile_data *data, const gchar *path);
159
153
 
160
 
static void ui_panel_accounts_setup(struct hbfile_data *data);
161
 
 
162
 
extern HbKvData CYA_ACC_TYPE[];
163
 
 
164
 
extern gchar *CYA_CATSUBCAT[];
165
 
 
166
 
 
167
154
 
168
155
static GtkActionEntry entries[] = {
169
156
 
256
243
/*  name         , icon-name, label, accelerator, tooltip, callback, is_active */
257
244
  { "Toolbar"    , NULL                 , N_("_Toolbar")  , NULL,    NULL,    G_CALLBACK (ui_mainwindow_action_toggle_toolbar), TRUE },
258
245
  { "Spending"   , NULL                 , N_("_Top spending") , NULL,    NULL,    G_CALLBACK (ui_mainwindow_action_toggle_topspending), TRUE },
259
 
  { "Upcoming"   , NULL                 , N_("_Scheduled list") , NULL,    NULL,    G_CALLBACK (ui_mainwindow_action_toggle_upcoming), TRUE },
 
246
  { "BottomLists", NULL                 , N_("_Bottom Lists") , NULL,    NULL,    G_CALLBACK (ui_mainwindow_action_toggle_upcoming), TRUE },
260
247
  { "AsMinor"    , NULL                 , N_("Euro minor"), "<control>M",    NULL,    G_CALLBACK (ui_mainwindow_action_toggle_minor), FALSE },
261
248
};
262
249
 
299
286
"      <menuitem action='Toolbar'/>"
300
287
"        <separator/>"
301
288
"      <menuitem action='Spending'/>"
302
 
"      <menuitem action='Upcoming'/>"
 
289
"      <menuitem action='BottomLists'/>"
303
290
"        <separator/>"
304
291
"      <menuitem action='AsMinor'/>"
305
292
"    </menu>"
523
510
                ui_mainwindow_update(widget, GINT_TO_POINTER(UF_TITLE+UF_SENSITIVE+UF_REFRESHALL));
524
511
 
525
512
                ui_start_assistant();
526
 
                //ui_mainwindow_populate_accounts(GLOBALS->mainwindow, NULL);
527
 
                //ui_mainwindow_scheduled_populate(GLOBALS->mainwindow, NULL);
528
 
                //ui_mainwindow_populate_topspending(GLOBALS->mainwindow, NULL);
 
513
                //ui_hub_account_populate(GLOBALS->mainwindow, NULL);
 
514
                //ui_hub_scheduled_populate(GLOBALS->mainwindow, NULL);
 
515
                //ui_hub_spending_populate(GLOBALS->mainwindow, NULL);
529
516
        }
530
517
}
531
518
 
633
620
        //our global list has changed, so update the treeview
634
621
        //todo: optimize this, should not call compute balance here
635
622
        account_compute_balances ();
636
 
        ui_mainwindow_populate_accounts(GLOBALS->mainwindow, NULL);
 
623
        ui_hub_account_populate(GLOBALS->mainwindow, NULL);
637
624
 
638
625
        ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_TITLE+UF_SENSITIVE+UF_BALANCE));
639
626
}
653
640
}
654
641
 
655
642
 
656
 
static void ui_mainwindow_defarchive(Archive *arc)
 
643
//TODO: not ideal to do this
 
644
void ui_mainwindow_defarchive(Archive *arc)
657
645
{
658
646
struct hbfile_data *data;
659
647
GtkTreeModel *model;
660
648
 
661
649
        data = g_object_get_data(G_OBJECT(GLOBALS->mainwindow), "inst_data");
662
650
 
663
 
        // upcoming list have direct pointer to the arc (which may have changed)
 
651
        // upcoming list have direct pointer to the arc (which may change during edit)
664
652
        model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_upc));
665
653
        gtk_list_store_clear (GTK_LIST_STORE(model));
666
654
 
667
655
        ui_arc_manage_dialog(arc);
668
656
 
669
 
        ui_mainwindow_scheduled_populate(GLOBALS->mainwindow, NULL);
 
657
        ui_hub_scheduled_populate(GLOBALS->mainwindow, NULL);
670
658
 
671
659
        ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_TITLE+UF_SENSITIVE));
672
660
}
756
744
        // top spending
757
745
        gtk_chart_show_minor(GTK_CHART(data->RE_pie), GLOBALS->minor);
758
746
        
759
 
        ui_panel_topspending_update(data->window, data);
 
747
        ui_hub_spending_update(data->window, data);
760
748
 
761
749
}
762
750
 
808
796
 
809
797
static void ui_mainwindow_action_checkscheduled(void)
810
798
{
811
 
        ui_mainwindow_scheduled_postall(GLOBALS->mainwindow, GINT_TO_POINTER(TRUE));
 
799
        ui_hub_scheduled_postall(GLOBALS->mainwindow, GINT_TO_POINTER(TRUE));
812
800
}
813
801
 
814
802
static void ui_mainwindow_action_statistic(void)
1114
1102
        gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_top))));
1115
1103
        
1116
1104
        data->showall = FALSE;
1117
 
        ui_panel_accounts_setup(data);
 
1105
        ui_hub_account_setup(data);
1118
1106
        
1119
1107
        hbfile_cleanup(file_clear);
1120
1108
        hbfile_setup(file_clear);
1179
1167
 
1180
1168
                        DB( g_print(" - added 1 transaction to %d\n", ope->kacc) );
1181
1169
 
1182
 
                        ui_mainwindow_populate_accounts(GLOBALS->mainwindow, NULL);
 
1170
                        ui_hub_account_populate(GLOBALS->mainwindow, NULL);
1183
1171
                        
1184
1172
                        count++;
1185
1173
                        //todo: still usefull ? store last date
1206
1194
        }
1207
1195
}
1208
1196
 
1209
 
struct tmptop
1210
 
{
1211
 
        guint32         key;
1212
 
        gdouble         value;
1213
 
};
1214
 
 
1215
 
 
1216
 
#define MAX_TOPSPENDING 10
1217
 
 
1218
 
 
1219
 
static gint tmptop_compare_func(struct tmptop *tt1, struct tmptop *tt2)
1220
 
{
1221
 
        return tt1->value > tt2->value ? 1 : -1;
1222
 
}
1223
 
 
1224
 
 
1225
 
static void ui_panel_topspending_update(GtkWidget *widget, gpointer user_data)
1226
 
{
1227
 
struct hbfile_data *data;
1228
 
GtkTreeModel *model;
1229
 
gchar *title;
1230
 
gchar strbuffer[G_ASCII_DTOSTR_BUF_SIZE];
1231
 
 
1232
 
        DB( g_print("\n[ui-mainwindow] topspending_update\n") );
1233
 
 
1234
 
        data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1235
 
 
1236
 
        hb_strfmon(strbuffer, G_ASCII_DTOSTR_BUF_SIZE-1, data->toptotal, GLOBALS->kcur, GLOBALS->minor);        
1237
 
        //hb_label_set_amount(GTK_LABEL(data->TX_topamount), total, GLOBALS->kcur, GLOBALS->minor);
1238
 
        title = g_strdup_printf("%s %s", _("Top spending"), strbuffer);
1239
 
 
1240
 
        model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_top));
1241
 
        
1242
 
        gtk_chart_set_color_scheme(GTK_CHART(data->RE_pie), PREFS->report_color_scheme);
1243
 
        gtk_chart_set_currency(GTK_CHART(data->RE_pie), GLOBALS->kcur);
1244
 
        gtk_chart_set_datas(GTK_CHART(data->RE_pie), model, LST_TOPSPEND_AMOUNT, title, NULL);
1245
 
 
1246
 
        g_free(title);
1247
 
 
1248
 
        //future usage
1249
 
        gchar *fu = _("Top %d spending"); title = fu;
1250
 
}
1251
 
 
1252
 
 
1253
 
static void ui_mainwindow_populate_topspending(GtkWidget *widget, gpointer user_data)
1254
 
{
1255
 
struct hbfile_data *data;
1256
 
GtkTreeModel *model;
1257
 
GtkTreeIter  iter;
1258
 
GList *list;
1259
 
gint type, range;
1260
 
guint n_result, i, n_items;
1261
 
GArray *garray;
1262
 
gdouble total, other;
1263
 
Account *acc;
1264
 
 
1265
 
        
1266
 
        DB( g_print("\n[ui-mainwindow] populate_topspending\n") );
1267
 
 
1268
 
        data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1269
 
 
1270
 
        type = hbtk_radio_get_active(GTK_CONTAINER(data->RA_type));
1271
 
        range = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_range));
1272
 
 
1273
 
        DB( g_print(" - type=%d, range=%d\n", type, range) );
1274
 
        DB( g_print(" - pref range=%d\n", PREFS->date_range_wal) );
1275
 
 
1276
 
        if(range == FLT_RANGE_OTHER)
1277
 
                return;
1278
 
        
1279
 
        filter_preset_daterange_set(data->filter, range, 0);
1280
 
        
1281
 
        
1282
 
        n_result = da_cat_get_max_key() + 1;
1283
 
        total = 0.0;
1284
 
 
1285
 
        DB( g_print(" - max key is %d\n", n_result) );
1286
 
 
1287
 
        /* allocate some memory */
1288
 
        garray = g_array_sized_new(FALSE, FALSE, sizeof(struct tmptop), n_result);
1289
 
 
1290
 
        if(garray)
1291
 
        {
1292
 
        struct tmptop zero = { .key=0, .value=0.0 };
1293
 
        GQueue *txn_queue;
1294
 
                
1295
 
                //DB( g_print(" - array length=%d\n", garray->len) );
1296
 
 
1297
 
                for(i=0 ; i<n_result ; i++)
1298
 
                {
1299
 
                        g_array_append_vals(garray, &zero, 1);
1300
 
                        //g_array_insert_vals(garray, i, &zero, 1);
1301
 
 
1302
 
                        //struct tmptop *tt = &g_array_index (garray, struct tmptop, i);
1303
 
                        //DB( g_print("%4d, %4d %f\n", i, tt->key, tt->value) );
1304
 
                }
1305
 
 
1306
 
                //DB( g_print("\n - end array length=%d\n", garray->len) );
1307
 
 
1308
 
                //todo: not ideal, has ot force to get_acc for each txn below
1309
 
                txn_queue = hbfile_transaction_get_partial(data->filter->mindate, data->filter->maxdate);
1310
 
 
1311
 
                /* compute the results */
1312
 
                list = g_queue_peek_head_link(txn_queue);
1313
 
                while (list != NULL)
1314
 
                {
1315
 
                Transaction *ope = list->data;
1316
 
 
1317
 
                        //DB( g_print(" - eval txn: '%s', cat=%d ==> flt-test=%d\n", ope->memo, ope->kcat, filter_txn_match(data->filter, ope)) );
1318
 
 
1319
 
                        if( !(ope->paymode == PAYMODE_INTXFER) )
1320
 
                        {
1321
 
                        guint32 pos = 0;
1322
 
                        gdouble trn_amount;
1323
 
 
1324
 
                                //todo: optimize here
1325
 
                                trn_amount = ope->amount;
1326
 
                                acc = da_acc_get(ope->kacc);
1327
 
                                if(acc)
1328
 
                                        trn_amount = hb_amount_base(ope->amount, acc->kcur);
1329
 
 
1330
 
                                if( ope->flags & OF_SPLIT )
1331
 
                                {
1332
 
                                guint nbsplit = da_splits_length(ope->splits);
1333
 
                                Split *split;
1334
 
                                struct tmptop *item;
1335
 
                                
1336
 
                                        for(i=0;i<nbsplit;i++)
1337
 
                                        {
1338
 
                                                split = da_splits_get(ope->splits, i);
1339
 
                                                pos = category_report_id(split->kcat, type);
1340
 
                                                if( pos <= garray->len )
1341
 
                                                {
1342
 
                                                        trn_amount = hb_amount_base(split->amount, acc->kcur);
1343
 
                                                        //trn_amount = split->amount;
1344
 
                                                        //#1297054 if( trn_amount < 0 ) {
1345
 
                                                                item = &g_array_index (garray, struct tmptop, pos);
1346
 
                                                                item->key = pos;
1347
 
                                                                item->value += trn_amount;
1348
 
                                                                //DB( g_print(" - stored %.2f to item %d\n", trn_amount, pos)  );
1349
 
                                                        //}
1350
 
                                                }
1351
 
                                        }
1352
 
                                }
1353
 
                                else
1354
 
                                {
1355
 
                                struct tmptop *item;
1356
 
 
1357
 
                                        pos = category_report_id(ope->kcat, type);
1358
 
                                        if( pos <= garray->len )
1359
 
                                        {
1360
 
                                                //#1297054 if( trn_amount < 0 ) {
1361
 
                                                        item = &g_array_index (garray, struct tmptop, pos);
1362
 
                                                        item->key = pos;
1363
 
                                                        item->value += trn_amount;
1364
 
                                                        //DB( g_print(" - stored %.2f to item %d\n", trn_amount, pos)  );
1365
 
                                                //}
1366
 
                                        }
1367
 
                                }
1368
 
 
1369
 
                        }
1370
 
 
1371
 
                        list = g_list_next(list);
1372
 
                }
1373
 
 
1374
 
                g_queue_free (txn_queue);
1375
 
                
1376
 
                // we need to sort this and limit before
1377
 
                g_array_sort(garray, (GCompareFunc)tmptop_compare_func);
1378
 
 
1379
 
                n_items = MIN(garray->len,MAX_TOPSPENDING);
1380
 
                other = 0;
1381
 
                for(i=0 ; i<garray->len ; i++)
1382
 
                {
1383
 
                struct tmptop *item;
1384
 
                
1385
 
                        item = &g_array_index (garray, struct tmptop, i);
1386
 
                        if(item->value < 0)
1387
 
                        {
1388
 
                                total += item->value;
1389
 
 
1390
 
                                if(i >= n_items)
1391
 
                                        other += item->value;
1392
 
 
1393
 
                                DB( g_print(" - %d : k='%d' v='%f' t='%f'\n", i, item->key, item->value, total) );
1394
 
 
1395
 
                        }
1396
 
                }
1397
 
 
1398
 
                model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_top));
1399
 
                gtk_list_store_clear (GTK_LIST_STORE(model));
1400
 
                g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
1401
 
                gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_top), NULL); /* Detach model from view */
1402
 
 
1403
 
                /* insert into the treeview */
1404
 
                for(i=0 ; i<MIN(garray->len,MAX_TOPSPENDING) ; i++)
1405
 
                {
1406
 
                gchar *name;
1407
 
                Category *entry;
1408
 
                struct tmptop *item;
1409
 
                gdouble value;
1410
 
                
1411
 
                        item = &g_array_index (garray, struct tmptop, i);
1412
 
 
1413
 
                        if(!item->value) continue;
1414
 
                        //#1767659 top spending should restrict to... spending
1415
 
                        if(item->value < 0)
1416
 
                        {
1417
 
                                value = hb_amount_round(item->value, 2);
1418
 
                                entry = da_cat_get(item->key);
1419
 
                                if(entry == NULL) continue;
1420
 
 
1421
 
                                name = da_cat_get_name (entry);
1422
 
 
1423
 
                                // append test
1424
 
                                gtk_list_store_append (GTK_LIST_STORE(model), &iter);
1425
 
                                gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1426
 
                                          LST_TOPSPEND_ID, i,
1427
 
                                          LST_TOPSPEND_KEY, 0,
1428
 
                                          LST_TOPSPEND_NAME, name,
1429
 
                                          LST_TOPSPEND_AMOUNT, value,
1430
 
                                          //LST_TOPSPEND_RATE, (gint)(((ABS(value)*100)/ABS(total)) + 0.5),
1431
 
                                          -1);
1432
 
                        }
1433
 
                }
1434
 
 
1435
 
                // append test
1436
 
                if(ABS(other) > 0)
1437
 
                {
1438
 
                        gtk_list_store_append (GTK_LIST_STORE(model), &iter);
1439
 
                        gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1440
 
                                  LST_TOPSPEND_ID, n_items,
1441
 
                                  LST_TOPSPEND_KEY, 0,
1442
 
                                  LST_TOPSPEND_NAME, _("Other"),
1443
 
                                  LST_TOPSPEND_AMOUNT, other,
1444
 
                                  //LST_TOPSPEND_RATE, (gint)(((ABS(other)*100)/ABS(total)) + 0.5),
1445
 
                                  -1);
1446
 
                }
1447
 
                        
1448
 
                /* Re-attach model to view */
1449
 
                gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_top), model);
1450
 
                g_object_unref(model);
1451
 
                
1452
 
                
1453
 
                // update chart and widgets
1454
 
                {
1455
 
                gchar *daterange;
1456
 
 
1457
 
                        data->toptotal = total;
1458
 
                        ui_panel_topspending_update(widget, data);
1459
 
                        
1460
 
                        daterange = filter_daterange_text_get(data->filter);
1461
 
                        gtk_widget_set_tooltip_markup(GTK_WIDGET(data->CY_range), daterange);
1462
 
                        g_free(daterange);
1463
 
                }
1464
 
        }
1465
 
        
1466
 
        /* free our memory */
1467
 
        g_array_free (garray, TRUE);
1468
 
 
1469
 
}
1470
 
 
1471
 
 
1472
 
/* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
1473
 
/* scheduled */
1474
 
/* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
1475
 
static Archive *
1476
 
ui_mainwindow_scheduled_get_selected_item(GtkTreeView *treeview)
1477
 
{
1478
 
GtkTreeSelection *treeselection;
1479
 
GtkTreeModel             *model;
1480
 
GtkTreeIter                      iter;
1481
 
 
1482
 
        treeselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
1483
 
        if( gtk_tree_selection_get_selected(treeselection, &model, &iter) )
1484
 
        {
1485
 
        Archive *arc;
1486
 
 
1487
 
                gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, LST_DSPUPC_DATAS, &arc, -1);
1488
 
                return arc;
1489
 
        }
1490
 
 
1491
 
        return NULL;
1492
 
}
1493
 
 
1494
 
 
1495
 
static void ui_mainwindow_scheduled_onRowActivated (GtkTreeView        *treeview,
1496
 
                       GtkTreePath        *path,
1497
 
                       GtkTreeViewColumn  *col,
1498
 
                       gpointer            userdata)
1499
 
{
1500
 
//struct hbfile_data *data;
1501
 
Archive *arc;
1502
 
 
1503
 
        DB( g_print ("\n[ui-mainwindow] A scheduled row has been double-clicked!\n") );
1504
 
 
1505
 
        //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(treeview, GTK_TYPE_WINDOW)), "inst_data");
1506
 
 
1507
 
        arc = ui_mainwindow_scheduled_get_selected_item(treeview);
1508
 
        ui_mainwindow_defarchive(arc);
1509
 
}
1510
 
 
1511
 
 
1512
 
static void ui_mainwindow_scheduled_do_post(Archive *arc, gboolean doedit, gpointer user_data)
1513
 
{
1514
 
struct hbfile_data *data = user_data;
1515
 
GtkWidget *window;
1516
 
gint result;
1517
 
Transaction *txn;
1518
 
 
1519
 
        window =  create_deftransaction_window(GTK_WINDOW(data->window), TRANSACTION_EDIT_ADD, TRUE, 0);
1520
 
 
1521
 
        /* fill in the transaction */
1522
 
        txn = da_transaction_malloc();
1523
 
        da_transaction_init_from_template(txn, arc);
1524
 
        txn->date = scheduled_get_postdate(arc, arc->nextdate);
1525
 
 
1526
 
        deftransaction_set_transaction(window, txn);
1527
 
 
1528
 
        result = gtk_dialog_run (GTK_DIALOG (window));
1529
 
 
1530
 
        DB( g_print(" - dialog result is %d\n", result) );
1531
 
 
1532
 
        if(result == HB_RESPONSE_ADD || result == GTK_RESPONSE_ACCEPT)
1533
 
        {
1534
 
                deftransaction_get(window, NULL);
1535
 
                transaction_add(GTK_WINDOW(GLOBALS->mainwindow), txn);
1536
 
                GLOBALS->changes_count++;
1537
 
 
1538
 
                scheduled_date_advance(arc);
1539
 
 
1540
 
                DB( g_print(" - added 1 transaction to %d\n", txn->kacc) );
1541
 
        }
1542
 
 
1543
 
        da_transaction_free(txn);
1544
 
 
1545
 
        deftransaction_dispose(window, NULL);
1546
 
        gtk_widget_destroy (window);
1547
 
 
1548
 
}
1549
 
 
1550
 
 
1551
 
static void ui_mainwindow_scheduled_editpost_cb(GtkWidget *widget, gpointer user_data)
1552
 
{
1553
 
struct hbfile_data *data = user_data;
1554
 
 
1555
 
        Archive *arc = ui_mainwindow_scheduled_get_selected_item(GTK_TREE_VIEW(data->LV_upc));
1556
 
 
1557
 
        if( (arc != NULL) )
1558
 
        {
1559
 
                ui_mainwindow_scheduled_do_post(arc, TRUE, data);
1560
 
                ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_SENSITIVE|UF_REFRESHALL));
1561
 
        }
1562
 
}
1563
 
 
1564
 
 
1565
 
static void ui_mainwindow_scheduled_post_cb(GtkWidget *widget, gpointer user_data)
1566
 
{
1567
 
struct hbfile_data *data = user_data;
1568
 
 
1569
 
        DB( g_print("\n[ui-mainwindow] scheduled post\n") );
1570
 
 
1571
 
        Archive *arc = ui_mainwindow_scheduled_get_selected_item(GTK_TREE_VIEW(data->LV_upc));
1572
 
 
1573
 
        if( (arc != NULL) )
1574
 
        {
1575
 
                if( scheduled_is_postable(arc) )
1576
 
                {
1577
 
                Transaction *txn = da_transaction_malloc ();
1578
 
 
1579
 
                        da_transaction_init_from_template(txn, arc);
1580
 
                        txn->date = scheduled_get_postdate(arc, arc->nextdate);
1581
 
                        transaction_add(GTK_WINDOW(GLOBALS->mainwindow), txn);
1582
 
 
1583
 
                        GLOBALS->changes_count++;
1584
 
                        scheduled_date_advance(arc);
1585
 
 
1586
 
                        da_transaction_free (txn);
1587
 
                }
1588
 
                else
1589
 
                {
1590
 
                        ui_mainwindow_scheduled_do_post(arc, FALSE, data);
1591
 
                }
1592
 
 
1593
 
                ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_SENSITIVE|UF_REFRESHALL));
1594
 
        }
1595
 
}
1596
 
 
1597
 
 
1598
 
static void ui_mainwindow_scheduled_skip_cb(GtkWidget *widget, gpointer user_data)
1599
 
{
1600
 
struct hbfile_data *data = user_data;
1601
 
 
1602
 
        Archive *arc = ui_mainwindow_scheduled_get_selected_item(GTK_TREE_VIEW(data->LV_upc));
1603
 
        if( (arc != NULL) && (arc->flags & OF_AUTO) )
1604
 
        {
1605
 
                GLOBALS->changes_count++;
1606
 
                scheduled_date_advance(arc);
1607
 
 
1608
 
                ui_mainwindow_scheduled_populate(GLOBALS->mainwindow, NULL);
1609
 
                ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_SENSITIVE));
1610
 
        }
1611
 
}
1612
 
 
1613
 
 
1614
 
 
1615
 
static void ui_mainwindow_scheduled_update(GtkWidget *widget, gpointer user_data)
1616
 
{
1617
 
struct hbfile_data *data;
1618
 
//gint filter;
1619
 
 
1620
 
        DB( g_print("\n[ui-mainwindow] scheduled update\n") );
1621
 
 
1622
 
        data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1623
 
 
1624
 
        //filter = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_sched_filter));
1625
 
 
1626
 
        Archive *arc = ui_mainwindow_scheduled_get_selected_item(GTK_TREE_VIEW(data->LV_upc));
1627
 
 
1628
 
        if(arc)
1629
 
        {
1630
 
                DB( g_print("archive is %s\n", arc->memo) );
1631
 
                
1632
 
                gtk_widget_set_sensitive(GTK_WIDGET(data->BT_sched_skip), TRUE);
1633
 
                gtk_widget_set_sensitive(GTK_WIDGET(data->BT_sched_post), TRUE);
1634
 
                gtk_widget_set_sensitive(GTK_WIDGET(data->BT_sched_editpost), TRUE);
1635
 
        }
1636
 
        else
1637
 
        {
1638
 
                gtk_widget_set_sensitive(GTK_WIDGET(data->BT_sched_skip), FALSE);
1639
 
                gtk_widget_set_sensitive(GTK_WIDGET(data->BT_sched_post), FALSE);
1640
 
                gtk_widget_set_sensitive(GTK_WIDGET(data->BT_sched_editpost), FALSE);
1641
 
        }
1642
 
 
1643
 
}
1644
 
 
1645
 
 
1646
 
 
1647
 
static void ui_mainwindow_scheduled_selection_cb(GtkTreeSelection *treeselection, gpointer user_data)
1648
 
{
1649
 
 
1650
 
        
1651
 
        ui_mainwindow_scheduled_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), GINT_TO_POINTER(UF_SENSITIVE));
1652
 
}
1653
 
 
1654
 
 
1655
 
 
1656
 
/*
1657
 
** called after load, importamiga, on demand
1658
 
*/
1659
 
void ui_mainwindow_scheduled_postall(GtkWidget *widget, gpointer user_data)
1660
 
{
1661
 
//struct hbfile_data *data;
1662
 
gint count;
1663
 
gint usermode = GPOINTER_TO_INT(user_data);
1664
 
 
1665
 
        DB( g_print("\n[ui-mainwindow] check scheduled\n") );
1666
 
 
1667
 
        //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1668
 
 
1669
 
        count = scheduled_post_all_pending();
1670
 
 
1671
 
        //inform the user
1672
 
        if(usermode == TRUE)
1673
 
        {
1674
 
        gchar *txt;
1675
 
 
1676
 
                //#125534
1677
 
                if( count > 0 )
1678
 
                {
1679
 
                        ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_REFRESHALL));
1680
 
                }
1681
 
                
1682
 
                if(count == 0)
1683
 
                        txt = _("No transaction to add");
1684
 
                else
1685
 
                        txt = _("transaction added: %d");
1686
 
 
1687
 
                ui_dialog_msg_infoerror(GTK_WINDOW(GLOBALS->mainwindow), GTK_MESSAGE_INFO,
1688
 
                        _("Check scheduled transactions result"),
1689
 
                        txt,
1690
 
                        count);
1691
 
        }
1692
 
 
1693
 
}
1694
 
 
1695
 
 
1696
 
static void ui_mainwindow_scheduled_populate(GtkWidget *widget, gpointer user_data)
1697
 
{
1698
 
struct hbfile_data *data;
1699
 
GtkTreeModel *model;
1700
 
GtkTreeIter  iter;
1701
 
GList *list;
1702
 
gdouble totexp = 0;
1703
 
gdouble totinc = 0;
1704
 
gint count = 0;
1705
 
gchar buffer[256];
1706
 
guint32 maxpostdate;
1707
 
GDate *date;
1708
 
//Account *acc;
1709
 
 
1710
 
        DB( g_print("\n[ui-mainwindow] scheduled populate list\n") );
1711
 
 
1712
 
        data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1713
 
 
1714
 
        model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_upc));
1715
 
        gtk_list_store_clear (GTK_LIST_STORE(model));
1716
 
 
1717
 
        homebank_app_date_get_julian();
1718
 
 
1719
 
        maxpostdate = scheduled_date_get_post_max();
1720
 
 
1721
 
        date = g_date_new_julian (maxpostdate);
1722
 
        g_date_strftime (buffer, 256-1, PREFS->date_format, date);
1723
 
        g_date_free(date);
1724
 
 
1725
 
        gtk_label_set_text(GTK_LABEL(data->LB_maxpostdate), buffer);
1726
 
 
1727
 
        
1728
 
        list = g_list_first(GLOBALS->arc_list);
1729
 
        while (list != NULL)
1730
 
        {
1731
 
        Archive *arc = list->data;
1732
 
        Account *acc;
1733
 
        gdouble inc, exp;
1734
 
        guint nbdays, nblate;
1735
 
 
1736
 
                if((arc->flags & OF_AUTO) ) //&& arc->kacc > 0)
1737
 
                {
1738
 
                        count++;
1739
 
                        nbdays = arc->nextdate - maxpostdate;
1740
 
                        nblate = scheduled_get_latepost_count(arc, GLOBALS->today);
1741
 
                        
1742
 
                        DB( g_print(" - append '%s' : %d\n", arc->memo, nbdays) );
1743
 
 
1744
 
                        if(arc->flags & OF_INCOME)
1745
 
                        {
1746
 
                                inc = arc->amount;
1747
 
                                exp = 0.0;
1748
 
                        }
1749
 
                        else
1750
 
                        {
1751
 
                                exp = arc->amount;
1752
 
                                inc = 0.0;
1753
 
                        }
1754
 
 
1755
 
                        /* insert normal txn */
1756
 
                        acc = da_acc_get(arc->kacc);
1757
 
                        if( acc)
1758
 
                        {
1759
 
                                totinc += hb_amount_base(inc, acc->kcur);
1760
 
                                totexp += hb_amount_base(exp, acc->kcur);
1761
 
                        }
1762
 
                        gtk_list_store_append (GTK_LIST_STORE(model), &iter);
1763
 
                        gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1764
 
                                  LST_DSPUPC_DATAS, arc,
1765
 
                              LST_DSPUPC_NEXT, nbdays,
1766
 
                                  LST_DSPUPC_ACCOUNT, acc,
1767
 
                              LST_DSPUPC_MEMO, arc->memo,
1768
 
                              LST_DSPUPC_EXPENSE, exp,
1769
 
                              LST_DSPUPC_INCOME, inc,
1770
 
                              LST_DSPUPC_NB_LATE, nblate,
1771
 
                                  -1);
1772
 
 
1773
 
                        /* insert internal xfer txn : 1378836 */
1774
 
                        if(arc->paymode == PAYMODE_INTXFER)
1775
 
                        {
1776
 
                                acc = da_acc_get(arc->kxferacc);
1777
 
                                if( acc)
1778
 
                                {
1779
 
                                        totinc += hb_amount_base(-inc, acc->kcur);
1780
 
                                        totexp += hb_amount_base(-exp, acc->kcur);
1781
 
                                }
1782
 
                                gtk_list_store_append (GTK_LIST_STORE(model), &iter);
1783
 
                                gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1784
 
                                          LST_DSPUPC_DATAS, arc,
1785
 
                                      LST_DSPUPC_NEXT, nbdays,
1786
 
                                          LST_DSPUPC_ACCOUNT, acc,
1787
 
                                          LST_DSPUPC_MEMO, arc->memo,
1788
 
                                          LST_DSPUPC_EXPENSE, -inc,
1789
 
                                          LST_DSPUPC_INCOME, -exp,
1790
 
                                          LST_DSPUPC_NB_LATE, nblate,
1791
 
                                          -1);
1792
 
                        }
1793
 
 
1794
 
                }
1795
 
                list = g_list_next(list);
1796
 
        }
1797
 
 
1798
 
        // insert total
1799
 
        if(count > 0 )
1800
 
        {
1801
 
                gtk_list_store_append (GTK_LIST_STORE(model), &iter);
1802
 
                gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1803
 
                          LST_DSPUPC_DATAS, NULL,
1804
 
                          LST_DSPUPC_ACCOUNT, NULL,
1805
 
                          LST_DSPUPC_MEMO, _("Total"),
1806
 
                          LST_DSPUPC_EXPENSE, totexp,
1807
 
                      LST_DSPUPC_INCOME, totinc,
1808
 
                  -1);
1809
 
        }
1810
 
 
1811
 
        ui_mainwindow_scheduled_update(widget, NULL);
1812
 
        
1813
 
}
1814
 
 
1815
1197
 
1816
1198
gboolean ui_mainwindow_open_backup_check_confirm(gchar *filepath)
1817
1199
{
1950
1332
 
1951
1333
                }
1952
1334
 
1953
 
                ui_mainwindow_populate_accounts(GLOBALS->mainwindow, NULL);
1954
 
                ui_mainwindow_scheduled_populate(GLOBALS->mainwindow, NULL);
1955
 
                ui_mainwindow_populate_topspending(GLOBALS->mainwindow, NULL);
 
1335
                ui_hub_account_populate(GLOBALS->mainwindow, NULL);
 
1336
                ui_hub_scheduled_populate(GLOBALS->mainwindow, NULL);
 
1337
                ui_hub_spending_populate(GLOBALS->mainwindow, NULL);
 
1338
                ui_hub_transaction_populate(data);
 
1339
        
1956
1340
                ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_TITLE+UF_SENSITIVE+UF_VISUAL));
1957
1341
        }
1958
1342
 
2045
1429
}
2046
1430
 
2047
1431
 
2048
 
static void ui_panel_accounts_expand_all(GtkWidget *widget, gpointer user_data)
2049
 
{
2050
 
struct hbfile_data *data;
2051
 
 
2052
 
        data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
2053
 
        gtk_tree_view_expand_all(GTK_TREE_VIEW(data->LV_acc));
2054
 
}
2055
 
 
2056
 
 
2057
 
static void ui_panel_accounts_collapse_all(GtkWidget *widget, gpointer user_data)
2058
 
{
2059
 
struct hbfile_data *data;
2060
 
 
2061
 
        data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
2062
 
        gtk_tree_view_collapse_all(GTK_TREE_VIEW(data->LV_acc));
2063
 
}
2064
 
 
2065
 
 
2066
 
static void ui_panel_accounts_groups_free(GHashTable *h_group)
2067
 
{
2068
 
GHashTableIter grp_iter;
2069
 
gpointer key, value;
2070
 
 
2071
 
        DB( g_print("\n free h_group\n") );
2072
 
 
2073
 
        g_hash_table_iter_init (&grp_iter, h_group);
2074
 
        while (g_hash_table_iter_next (&grp_iter, &key, &value))
2075
 
        {
2076
 
        PnlAccGrp *group = value;
2077
 
        
2078
 
                g_ptr_array_free (group->acclist, TRUE);
2079
 
                g_free(group);
2080
 
        }
2081
 
 
2082
 
        g_hash_table_destroy (h_group);  
2083
 
}
2084
 
 
2085
 
 
2086
 
static GHashTable *ui_panel_accounts_groups_get(GtkTreeView *treeview, gint groupby, gboolean showall)
2087
 
{
2088
 
GHashTable *h_group;
2089
 
GList *lacc, *elt;
2090
 
gchar *groupname;
2091
 
gint nballoc;
2092
 
        
2093
 
        DB( g_print("\n[ui-mainwindow] accounts_groups_get\n") );
2094
 
 
2095
 
        nballoc = da_acc_length ();
2096
 
        
2097
 
        DB( g_print(" %d accounts\n", nballoc) );
2098
 
        
2099
 
        h_group = g_hash_table_new_full(g_str_hash, g_str_equal, (GDestroyNotify)g_free, NULL);
2100
 
 
2101
 
        lacc = g_hash_table_get_values(GLOBALS->h_acc);
2102
 
        elt = g_list_first(lacc);
2103
 
        while (elt != NULL)
2104
 
        {
2105
 
        Account *acc = elt->data;
2106
 
        PnlAccGrp *group;
2107
 
        
2108
 
                //#1674045 ony rely on nosummary
2109
 
                //if( showall || !(acc->flags & (AF_CLOSED|AF_NOSUMMARY)) )
2110
 
                if( showall || !(acc->flags & AF_NOSUMMARY) )
2111
 
                {
2112
 
                        switch( groupby )
2113
 
                        {
2114
 
                                case DSPACC_GROUP_BY_BANK:
2115
 
                                {
2116
 
                                        groupname = _("(no institution)");
2117
 
                                        if( (acc->bankname != NULL) && strlen(acc->bankname) > 0 ) 
2118
 
                                                groupname = acc->bankname;
2119
 
                                }
2120
 
                                break;
2121
 
 
2122
 
                                default:
2123
 
                                        //pre 5.1.3 historical by type display
2124
 
                                        groupname = hbtk_get_label(CYA_ACC_TYPE, acc->type);
2125
 
                                break;
2126
 
                        }
2127
 
 
2128
 
                        if( g_hash_table_contains(h_group, groupname) == FALSE )
2129
 
                        {
2130
 
                                group = g_malloc0(sizeof(PnlAccGrp));
2131
 
                                if( group )
2132
 
                                {
2133
 
                                        group->acclist = g_ptr_array_sized_new(nballoc);
2134
 
                                        group->expanded = list_account_level1_expanded(treeview, groupname);
2135
 
                                        g_hash_table_insert(h_group, g_strdup(groupname), group );
2136
 
                                        DB( g_print(" grp '%s' exp:%d\n", groupname, group->expanded) );
2137
 
                                }
2138
 
                        }
2139
 
 
2140
 
                        group = g_hash_table_lookup(h_group, groupname);
2141
 
                        if( group != NULL )
2142
 
                        {
2143
 
                                g_ptr_array_add(group->acclist, (gpointer)acc);
2144
 
                                DB( g_print(" + acc '%s'\n", acc->name) );
2145
 
                        }
2146
 
                }
2147
 
                elt = g_list_next(elt);
2148
 
        }
2149
 
 
2150
 
        g_list_free(lacc);
2151
 
        
2152
 
        return h_group;
2153
 
}
2154
 
 
2155
 
 
2156
 
void ui_mainwindow_populate_accounts(GtkWidget *widget, gpointer user_data)
2157
 
{
2158
 
struct hbfile_data *data;
2159
 
GtkTreeModel *model;
2160
 
GtkTreeIter  iter1, child_iter;
2161
 
Account *acc;
2162
 
guint j, nbtype;
2163
 
gdouble gtbank, gttoday, gtfuture;
2164
 
GHashTable *h_group;
2165
 
GHashTableIter grp_iter;
2166
 
gpointer key, value;
2167
 
 
2168
 
        DB( g_print("\n[ui-mainwindow] populate accounts\n") );
2169
 
 
2170
 
        data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
2171
 
        h_group = ui_panel_accounts_groups_get(GTK_TREE_VIEW(data->LV_acc), PREFS->pnl_acc_show_by, data->showall);
2172
 
 
2173
 
        DB( g_print("\n\n populate listview, %d group(s)\n", g_hash_table_size(h_group)) );
2174
 
 
2175
 
        nbtype = 0;
2176
 
        gtbank = gttoday = gtfuture = 0;
2177
 
        model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_acc));
2178
 
        gtk_tree_store_clear (GTK_TREE_STORE(model));
2179
 
 
2180
 
        g_hash_table_iter_init (&grp_iter, h_group);
2181
 
        while (g_hash_table_iter_next (&grp_iter, &key, &value))
2182
 
        {
2183
 
        PnlAccGrp *group = value;
2184
 
        gdouble tbank, ttoday, tfuture;
2185
 
        gint position;
2186
 
 
2187
 
                if(group != NULL)
2188
 
                {
2189
 
                        nbtype++;
2190
 
                        //1: Header: Bank, Cash, ...
2191
 
                        DB( g_print(" g '%s'\n", (gchar *)key) );
2192
 
 
2193
 
                        //#1663399 keep type position like in dropdown
2194
 
                        position = 0;
2195
 
                        if( PREFS->pnl_acc_show_by == DSPACC_GROUP_BY_TYPE )
2196
 
                        {
2197
 
                        gint t = 0;     
2198
 
 
2199
 
                                while(CYA_ACC_TYPE[t].name != NULL && t < 32)
2200
 
                                {
2201
 
                                        if( !strcmp(CYA_ACC_TYPE[t].name, key) )
2202
 
                                                break;
2203
 
                                        t++;
2204
 
                                }
2205
 
 
2206
 
                                position = t;
2207
 
                        }
2208
 
 
2209
 
                        gtk_tree_store_append (GTK_TREE_STORE(model), &iter1, NULL);
2210
 
                        gtk_tree_store_set (GTK_TREE_STORE(model), &iter1,
2211
 
                                          LST_DSPACC_POS, position,
2212
 
                                          LST_DSPACC_DATATYPE, DSPACC_TYPE_HEADER,
2213
 
                                          LST_DSPACC_NAME, key,
2214
 
                                          -1);
2215
 
 
2216
 
                        //2: Accounts for real
2217
 
                        tbank = ttoday = tfuture = 0;
2218
 
                        for(j=0;j<group->acclist->len;j++)
2219
 
                        {
2220
 
                                acc = g_ptr_array_index(group->acclist, j);
2221
 
 
2222
 
                                //tbank += acc->bal_bank;
2223
 
                                //ttoday += acc->bal_today;
2224
 
                                //tfuture += acc->bal_future;
2225
 
                                tbank += hb_amount_base(acc->bal_bank, acc->kcur);
2226
 
                                ttoday += hb_amount_base(acc->bal_today, acc->kcur);
2227
 
                                tfuture += hb_amount_base(acc->bal_future, acc->kcur);
2228
 
 
2229
 
                                DB( g_print("  + '%s' :: %.2f %.2f %.2f\n", acc->name, acc->bal_bank, acc->bal_today, acc->bal_future) );
2230
 
 
2231
 
                                gtk_tree_store_append (GTK_TREE_STORE(model), &child_iter, &iter1);
2232
 
                                gtk_tree_store_set (GTK_TREE_STORE(model), &child_iter,
2233
 
                                                LST_DSPACC_DATAS, acc,
2234
 
                                                LST_DSPACC_DATATYPE, DSPACC_TYPE_NORMAL,
2235
 
                                                LST_DSPACC_BANK, acc->bal_bank,
2236
 
                                                LST_DSPACC_TODAY, acc->bal_today,
2237
 
                                                LST_DSPACC_FUTURE, acc->bal_future,
2238
 
                                          -1);
2239
 
                        }
2240
 
 
2241
 
                        if(group->acclist->len > 1)
2242
 
                        {
2243
 
                                DB( g_print("  + total :: %.2f %.2f %.2f\n", tbank, ttoday, tfuture) );
2244
 
 
2245
 
                                // insert the total line
2246
 
                                gtk_tree_store_append (GTK_TREE_STORE(model), &child_iter, &iter1);
2247
 
                                gtk_tree_store_set (GTK_TREE_STORE(model), &child_iter,
2248
 
                                                LST_DSPACC_DATATYPE, DSPACC_TYPE_SUBTOTAL,
2249
 
                                                LST_DSPACC_NAME, _("Total"),
2250
 
                                                LST_DSPACC_BANK, tbank,
2251
 
                                                LST_DSPACC_TODAY, ttoday,
2252
 
                                                LST_DSPACC_FUTURE, tfuture,
2253
 
                                                  -1);
2254
 
                        }
2255
 
 
2256
 
                        /* set balance to header to display when collasped */
2257
 
                        DB( g_print(" (enrich group total header) :: %.2f %.2f %.2f\n", tbank, ttoday, tfuture) );
2258
 
                        gtk_tree_store_set (GTK_TREE_STORE(model), &iter1,
2259
 
                                        LST_DSPACC_BANK, tbank,
2260
 
                                        LST_DSPACC_TODAY, ttoday,
2261
 
                                        LST_DSPACC_FUTURE, tfuture,
2262
 
                                          -1);
2263
 
 
2264
 
                        if( group->expanded == TRUE )
2265
 
                        {
2266
 
                        GtkTreePath *tmppath = gtk_tree_model_get_path(model, &iter1);
2267
 
 
2268
 
                                DB( g_print(" expanding '%s'\n", (gchar *)key) );
2269
 
                                gtk_tree_view_expand_row(GTK_TREE_VIEW(data->LV_acc), tmppath, TRUE);
2270
 
                                gtk_tree_path_free(tmppath);
2271
 
                        }
2272
 
                        
2273
 
                        /* add to grand total */
2274
 
                        gtbank += tbank;
2275
 
                        gttoday += ttoday;
2276
 
                        gtfuture += tfuture;
2277
 
 
2278
 
                }
2279
 
 
2280
 
        }
2281
 
 
2282
 
        DB( g_print(" + grand total :: %.2f %.2f %.2f\n", gtbank, gttoday, gtfuture) );
2283
 
 
2284
 
        // Grand total
2285
 
        if( nbtype > 1 )
2286
 
        {
2287
 
                gtk_tree_store_append (GTK_TREE_STORE(model), &iter1, NULL);
2288
 
                gtk_tree_store_set (GTK_TREE_STORE(model), &iter1,
2289
 
                                        LST_DSPACC_DATATYPE, DSPACC_TYPE_SUBTOTAL,
2290
 
                                        LST_DSPACC_NAME, _("Grand total"),
2291
 
                                        LST_DSPACC_BANK, gtbank,
2292
 
                                        LST_DSPACC_TODAY, gttoday,
2293
 
                                        LST_DSPACC_FUTURE, gtfuture,
2294
 
                                  -1);
2295
 
        }
2296
 
 
2297
 
        //gtk_tree_view_expand_all(GTK_TREE_VIEW(data->LV_acc));
2298
 
        
2299
 
        ui_panel_accounts_groups_free(h_group);
2300
 
 
2301
 
}
2302
 
 
2303
 
 
2304
1432
void ui_mainwindow_update(GtkWidget *widget, gpointer user_data)
2305
1433
{
2306
1434
struct hbfile_data *data;
2490
1618
        {
2491
1619
                DB( g_print(" 16: refreshall\n") );
2492
1620
 
2493
 
                ui_mainwindow_populate_accounts(GLOBALS->mainwindow, NULL);
2494
 
                ui_mainwindow_populate_topspending(GLOBALS->mainwindow, NULL);
2495
 
                ui_mainwindow_scheduled_populate(GLOBALS->mainwindow, NULL);
 
1621
                ui_hub_account_populate(GLOBALS->mainwindow, NULL);
 
1622
                ui_hub_spending_populate(GLOBALS->mainwindow, NULL);
 
1623
                ui_hub_scheduled_populate(GLOBALS->mainwindow, NULL);
 
1624
                ui_hub_transaction_populate(data);
2496
1625
        }
2497
1626
 
2498
1627
 
2557
1686
        GdkWindow *gdk_window = gtk_widget_get_window(GTK_WIDGET(widget));
2558
1687
        GdkWindowState state = gdk_window_get_state(gdk_window);
2559
1688
        wg->s = (state & GDK_WINDOW_STATE_MAXIMIZED) ? 1 : 0;
2560
 
        
2561
1689
        DB( g_print(" window: l=%d, t=%d, w=%d, h=%d s=%d, state=%d\n", wg->l, wg->t, wg->w, wg->h, wg->s, state & GDK_WINDOW_STATE_MAXIMIZED) );
2562
1690
 
2563
1691
        PREFS->wal_vpaned = gtk_paned_get_position(GTK_PANED(data->vpaned));
2564
1692
        PREFS->wal_hpaned = gtk_paned_get_position(GTK_PANED(data->hpaned));
2565
 
 
2566
1693
        DB( g_print(" - vpaned=%d hpaned=%d\n", PREFS->wal_vpaned, PREFS->wal_hpaned) );
2567
1694
 
 
1695
        if(PREFS->pnl_list_tab)
 
1696
                g_free(PREFS->pnl_list_tab);
 
1697
        PREFS->pnl_list_tab = g_strdup(gtk_stack_get_visible_child_name(GTK_STACK(data->stack)));
 
1698
        
2568
1699
        //todo
2569
1700
        if(ui_dialog_msg_savechanges(widget, NULL) == FALSE)
2570
1701
        {
2932
2063
}
2933
2064
 
2934
2065
 
2935
 
/* Callback function for the undo action */
2936
 
/*static void
2937
 
activate_action (GSimpleAction *action, GVariant *parameter, gpointer user_data)
2938
 
{
2939
 
  g_print ("Action %s activated\n", g_action_get_name (G_ACTION (action)));
2940
 
}*/
2941
 
 
2942
 
static void
2943
 
activate_toggle (GSimpleAction *action, GVariant *parameter, gpointer user_data)
2944
 
{
2945
 
struct hbfile_data *data = user_data;
2946
 
  GVariant *old_state, *new_state;
2947
 
 
2948
 
  old_state = g_action_get_state (G_ACTION (action));
2949
 
  new_state = g_variant_new_boolean (!g_variant_get_boolean (old_state));
2950
 
 
2951
 
  DB( g_print ("Toggle action %s activated, state changes from %d to %d\n",
2952
 
           g_action_get_name (G_ACTION (action)),
2953
 
           g_variant_get_boolean (old_state),
2954
 
           g_variant_get_boolean (new_state)) );
2955
 
 
2956
 
        data->showall = g_variant_get_boolean (new_state);
2957
 
        ui_mainwindow_populate_accounts(GLOBALS->mainwindow, NULL);
2958
 
 
2959
 
  g_simple_action_set_state (action, new_state);
2960
 
  g_variant_unref (old_state);
2961
 
}
2962
 
 
2963
 
static void
2964
 
activate_radio (GSimpleAction *action, GVariant *parameter, gpointer user_data)
2965
 
{
2966
 
//struct hbfile_data *data = user_data;
2967
 
GVariant *old_state, *new_state;
2968
 
 
2969
 
  old_state = g_action_get_state (G_ACTION (action));
2970
 
  new_state = g_variant_new_string (g_variant_get_string (parameter, NULL));
2971
 
 
2972
 
  DB( g_print ("Radio action %s activated, state changes from %s to %s\n",
2973
 
           g_action_get_name (G_ACTION (action)),
2974
 
           g_variant_get_string (old_state, NULL),
2975
 
           g_variant_get_string (new_state, NULL)) );
2976
 
 
2977
 
        PREFS->pnl_acc_show_by = DSPACC_GROUP_BY_TYPE;
2978
 
        if( !strcmp("bank", g_variant_get_string(new_state, NULL)) )
2979
 
                PREFS->pnl_acc_show_by = DSPACC_GROUP_BY_BANK;
2980
 
 
2981
 
        ui_mainwindow_populate_accounts(GLOBALS->mainwindow, NULL);
2982
 
 
2983
 
  g_simple_action_set_state (action, new_state);
2984
 
  g_variant_unref (old_state);
2985
 
}
2986
 
 
2987
 
 
2988
 
static const GActionEntry actions[] = {
2989
 
//      name, function(), type, state, 
2990
 
//  { "paste", activate_action, NULL, NULL,      NULL, {0,0,0} },
2991
 
        { "showall", activate_toggle, NULL, "false" , NULL, {0,0,0} },
2992
 
        { "groupby", activate_radio ,  "s", "'type'", NULL, {0,0,0} }
2993
 
};
2994
 
 
2995
 
 
2996
 
static void ui_panel_accounts_setup(struct hbfile_data *data)
2997
 
{
2998
 
GAction *action;
2999
 
GVariant *new_state;
3000
 
 
3001
 
        if( !G_IS_SIMPLE_ACTION_GROUP(data->action_group_acc) )
3002
 
                return;
3003
 
 
3004
 
        action = g_action_map_lookup_action (G_ACTION_MAP (data->action_group_acc), "showall");
3005
 
        if( action )
3006
 
        {
3007
 
                new_state = g_variant_new_boolean (data->showall);
3008
 
                g_simple_action_set_state (G_SIMPLE_ACTION(action), new_state);
3009
 
        }
3010
 
        
3011
 
        action = g_action_map_lookup_action (G_ACTION_MAP (data->action_group_acc), "groupby");
3012
 
        if( action )
3013
 
        {
3014
 
                const gchar *value = (PREFS->pnl_acc_show_by == DSPACC_GROUP_BY_TYPE) ? "type" : "bank";
3015
 
                new_state = g_variant_new_string (value);
3016
 
                g_simple_action_set_state (G_SIMPLE_ACTION (action), new_state);
3017
 
        }
3018
 
 
3019
 
}
3020
 
 
3021
 
 
3022
 
static GtkWidget *ui_mainwindow_create_youraccounts(struct hbfile_data *data)
3023
 
{
3024
 
GtkWidget *panel, *label, *widget, *sw, *tbar, *hbox, *image;
3025
 
GtkToolItem *toolitem;
3026
 
 
3027
 
        panel = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3028
 
        gtk_container_set_border_width(GTK_CONTAINER(panel), SPACING_SMALL);
3029
 
 
3030
 
        sw = gtk_scrolled_window_new (NULL, NULL);
3031
 
        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
3032
 
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3033
 
        gtk_box_pack_start (GTK_BOX (panel), sw, TRUE, TRUE, 0);
3034
 
        widget = (GtkWidget *)create_list_account();
3035
 
        data->LV_acc = widget;
3036
 
        gtk_container_add (GTK_CONTAINER (sw), widget);
3037
 
 
3038
 
        //list toolbar
3039
 
        tbar = gtk_toolbar_new();
3040
 
        gtk_toolbar_set_icon_size (GTK_TOOLBAR(tbar), GTK_ICON_SIZE_MENU);
3041
 
        gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_ICONS);
3042
 
        gtk_style_context_add_class (gtk_widget_get_style_context (tbar), GTK_STYLE_CLASS_INLINE_TOOLBAR);
3043
 
        gtk_box_pack_start (GTK_BOX (panel), tbar, FALSE, FALSE, 0);
3044
 
 
3045
 
        label = make_label_group(_("Your accounts"));
3046
 
        toolitem = gtk_tool_item_new();
3047
 
        gtk_container_add (GTK_CONTAINER(toolitem), label);
3048
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3049
 
 
3050
 
        toolitem = gtk_separator_tool_item_new ();
3051
 
        gtk_tool_item_set_expand (toolitem, TRUE);
3052
 
        gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
3053
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3054
 
 
3055
 
        hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
3056
 
        toolitem = gtk_tool_item_new();
3057
 
        gtk_container_add (GTK_CONTAINER(toolitem), hbox);
3058
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3059
 
        
3060
 
                widget = make_image_button(ICONNAME_HB_BUTTON_EXPAND, _("Expand all"));
3061
 
                data->BT_expandall = widget;
3062
 
                gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
3063
 
 
3064
 
                widget = make_image_button(ICONNAME_HB_BUTTON_COLLAPSE, _("Collapse all"));
3065
 
                data->BT_collapseall = widget;
3066
 
                gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
3067
 
 
3068
 
        toolitem = gtk_separator_tool_item_new ();
3069
 
        gtk_tool_item_set_expand (toolitem, FALSE);
3070
 
        gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
3071
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3072
 
 
3073
 
 
3074
 
        //gmenu test (see test folder into gtk)
3075
 
GMenu *menu, *section;
3076
 
 
3077
 
        menu = g_menu_new ();
3078
 
        //g_menu_append (menumodel, "About", "actions.undo");
3079
 
        //g_menu_append (menumodel, "Test", "actions.redo");
3080
 
        section = g_menu_new ();
3081
 
        g_menu_append (section, _("Show all"), "actions.showall");
3082
 
        g_menu_append_section(menu, NULL, G_MENU_MODEL(section));
3083
 
        g_object_unref (section);
3084
 
 
3085
 
        section = g_menu_new ();
3086
 
        g_menu_append (section, _("By type"), "actions.groupby::type");
3087
 
        g_menu_append (section, _("By institution"), "actions.groupby::bank");
3088
 
        g_menu_append_section(menu, NULL, G_MENU_MODEL(section));
3089
 
        g_object_unref (section);
3090
 
 
3091
 
 
3092
 
        GSimpleActionGroup *group = g_simple_action_group_new ();
3093
 
        data->action_group_acc = group;
3094
 
        g_action_map_add_action_entries (G_ACTION_MAP (group), actions, G_N_ELEMENTS (actions), data);
3095
 
 
3096
 
 
3097
 
        widget = gtk_menu_button_new();
3098
 
        gtk_menu_button_set_direction (GTK_MENU_BUTTON(widget), GTK_ARROW_UP);
3099
 
        gtk_widget_set_halign (widget, GTK_ALIGN_END);
3100
 
        image = gtk_image_new_from_icon_name (ICONNAME_EMBLEM_SYSTEM, GTK_ICON_SIZE_MENU);
3101
 
        g_object_set (widget, "image", image,  NULL);
3102
 
 
3103
 
        toolitem = gtk_tool_item_new();
3104
 
        gtk_container_add (GTK_CONTAINER(toolitem), widget);
3105
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3106
 
 
3107
 
        gtk_widget_insert_action_group (widget, "actions", G_ACTION_GROUP(group));
3108
 
        gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (widget), G_MENU_MODEL (menu));
3109
 
 
3110
 
        return panel;
3111
 
}
3112
 
 
3113
 
 
3114
 
static GtkWidget *ui_mainwindow_create_topspending(struct hbfile_data *data)
3115
 
{
3116
 
GtkWidget *panel, *hbox, *tbar;
3117
 
GtkWidget *label, *widget;
3118
 
GtkToolItem *toolitem;
3119
 
 
3120
 
        widget = (GtkWidget *)create_list_topspending();
3121
 
        data->LV_top = widget;
3122
 
 
3123
 
        panel = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3124
 
        gtk_container_set_border_width(GTK_CONTAINER(panel), SPACING_SMALL);
3125
 
        data->GR_top = panel;
3126
 
 
3127
 
        /* chart + listview */
3128
 
        hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
3129
 
        gtk_box_pack_start (GTK_BOX (panel), hbox, TRUE, TRUE, 0);
3130
 
 
3131
 
        widget = gtk_chart_new(CHART_TYPE_PIE);
3132
 
        data->RE_pie = widget;
3133
 
        gtk_chart_set_minor_prefs(GTK_CHART(widget), PREFS->euro_value, PREFS->minor_cur.symbol);
3134
 
        gtk_chart_show_legend(GTK_CHART(data->RE_pie), TRUE, TRUE);
3135
 
        gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
3136
 
 
3137
 
        //list toolbar
3138
 
        tbar = gtk_toolbar_new();
3139
 
        gtk_toolbar_set_icon_size (GTK_TOOLBAR(tbar), GTK_ICON_SIZE_MENU);
3140
 
        gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_ICONS);
3141
 
        gtk_style_context_add_class (gtk_widget_get_style_context (tbar), GTK_STYLE_CLASS_INLINE_TOOLBAR);
3142
 
        gtk_box_pack_start (GTK_BOX (panel), tbar, FALSE, FALSE, 0);
3143
 
 
3144
 
        label = make_label_group(_("Where your money goes"));
3145
 
        toolitem = gtk_tool_item_new();
3146
 
        gtk_container_add (GTK_CONTAINER(toolitem), label);
3147
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3148
 
 
3149
 
        toolitem = gtk_separator_tool_item_new ();
3150
 
        gtk_tool_item_set_expand (toolitem, TRUE);
3151
 
        gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
3152
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3153
 
 
3154
 
        /* total + date range */
3155
 
        hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
3156
 
        toolitem = gtk_tool_item_new();
3157
 
        gtk_container_add (GTK_CONTAINER(toolitem), hbox);
3158
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3159
 
        
3160
 
        data->CY_range = make_daterange(label, FALSE);
3161
 
        gtk_box_pack_end (GTK_BOX (hbox), data->CY_range, FALSE, FALSE, 0);
3162
 
 
3163
 
        widget = hbtk_radio_new(CYA_CATSUBCAT, TRUE);
3164
 
        data->RA_type = widget;
3165
 
        gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
3166
 
 
3167
 
        return panel;
3168
 
}
3169
 
 
3170
 
 
3171
 
static GtkWidget *ui_mainwindow_scheduled_create(struct hbfile_data *data)
3172
 
{
3173
 
GtkWidget *panel, *hbox, *vbox, *bbox, *sw, *tbar;
3174
 
GtkWidget *label, *widget;
3175
 
GtkToolItem *toolitem;
3176
 
        
3177
 
        panel = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3178
 
        gtk_container_set_border_width(GTK_CONTAINER(panel), SPACING_SMALL);
3179
 
        data->GR_upc = panel;
3180
 
 
3181
 
        vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3182
 
        //gtk_widget_set_margin_top(GTK_WIDGET(vbox), 0);
3183
 
        //gtk_widget_set_margin_bottom(GTK_WIDGET(vbox), SPACING_SMALL);
3184
 
        //gtk_widget_set_margin_start(GTK_WIDGET(vbox), 2*SPACING_SMALL);
3185
 
        //gtk_widget_set_margin_end(GTK_WIDGET(vbox), SPACING_SMALL);
3186
 
        gtk_box_pack_start (GTK_BOX (panel), vbox, TRUE, TRUE, 0);
3187
 
 
3188
 
        sw = gtk_scrolled_window_new (NULL, NULL);
3189
 
        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
3190
 
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3191
 
        gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
3192
 
        
3193
 
        widget = (GtkWidget *)create_list_upcoming();
3194
 
        data->LV_upc = widget;
3195
 
        gtk_container_add (GTK_CONTAINER (sw), widget);
3196
 
 
3197
 
        tbar = gtk_toolbar_new();
3198
 
        gtk_toolbar_set_icon_size (GTK_TOOLBAR(tbar), GTK_ICON_SIZE_MENU);
3199
 
        gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_ICONS);
3200
 
        gtk_style_context_add_class (gtk_widget_get_style_context (tbar), GTK_STYLE_CLASS_INLINE_TOOLBAR);
3201
 
        gtk_box_pack_start (GTK_BOX (vbox), tbar, FALSE, FALSE, 0);
3202
 
 
3203
 
        label = make_label_group(_("Scheduled transactions"));
3204
 
        toolitem = gtk_tool_item_new();
3205
 
        gtk_container_add (GTK_CONTAINER(toolitem), label);
3206
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3207
 
 
3208
 
        toolitem = gtk_separator_tool_item_new ();
3209
 
        gtk_tool_item_set_expand (toolitem, FALSE);
3210
 
        gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
3211
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3212
 
 
3213
 
 
3214
 
        bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
3215
 
        toolitem = gtk_tool_item_new();
3216
 
        gtk_container_add (GTK_CONTAINER(toolitem), bbox);
3217
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3218
 
 
3219
 
                widget = gtk_button_new_with_label(_("Skip"));
3220
 
                data->BT_sched_skip = widget;
3221
 
                gtk_box_pack_start (GTK_BOX (bbox), widget, FALSE, FALSE, 0);
3222
 
 
3223
 
                widget = gtk_button_new_with_label(_("Edit & Post"));
3224
 
                data->BT_sched_editpost = widget;
3225
 
                gtk_box_pack_start (GTK_BOX (bbox), widget, FALSE, FALSE, 0);
3226
 
 
3227
 
                //TRANSLATORS: Posting a scheduled transaction is the action to materialize it into its target account.
3228
 
                //TRANSLATORS: Before that action the automated transaction occurrence is pending and not yet really existing.
3229
 
                widget = gtk_button_new_with_label (_("Post"));
3230
 
                data->BT_sched_post = widget;
3231
 
                gtk_box_pack_start (GTK_BOX (bbox), widget, FALSE, FALSE, 0);
3232
 
 
3233
 
        toolitem = gtk_separator_tool_item_new ();
3234
 
        gtk_tool_item_set_expand (toolitem, FALSE);
3235
 
        gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
3236
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3237
 
 
3238
 
        hbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
3239
 
        gtk_widget_set_valign (hbox, GTK_ALIGN_CENTER);
3240
 
        toolitem = gtk_tool_item_new();
3241
 
        gtk_container_add (GTK_CONTAINER(toolitem), hbox);
3242
 
        gtk_toolbar_insert(GTK_TOOLBAR(tbar), GTK_TOOL_ITEM(toolitem), -1);
3243
 
 
3244
 
                label = make_label(_("maximum post date"), 0.0, 0.7);
3245
 
                gtk_widget_set_halign (label, GTK_ALIGN_CENTER);
3246
 
                gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_SMALL, -1);
3247
 
                gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
3248
 
 
3249
 
                label = make_label(NULL, 0.0, 0.7);
3250
 
                data->LB_maxpostdate = label;
3251
 
                gtk_widget_set_halign (label, GTK_ALIGN_CENTER);
3252
 
                gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_SMALL, -1);
3253
 
                gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
3254
 
 
3255
 
        return panel;
3256
 
}
3257
 
 
3258
 
 
3259
2066
/*
3260
2067
** the window creation
3261
2068
*/
3263
2070
{
3264
2071
struct hbfile_data *data;
3265
2072
struct WinGeometry *wg;
3266
 
GtkWidget *mainvbox, *vbox, *vpaned, *hpaned;
3267
 
GtkWidget *widget;
 
2073
GtkWidget *mainvbox, *vbox, *box, *vpaned, *hpaned, *sidebar, *stack;
 
2074
GtkWidget *widget, *page;
3268
2075
GtkWidget *window;
3269
2076
GtkAction *action;
3270
2077
 
3308
2115
        data->vpaned = vpaned;
3309
2116
    gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
3310
2117
 
3311
 
                hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
3312
 
                data->hpaned = hpaned;
3313
 
                gtk_paned_pack1 (GTK_PANED(vpaned), hpaned, FALSE, FALSE);
3314
 
 
3315
 
                widget = ui_mainwindow_scheduled_create(data);
3316
 
                gtk_paned_pack2 (GTK_PANED(vpaned), widget, TRUE, FALSE);
3317
 
 
3318
 
                widget = ui_mainwindow_create_youraccounts(data);
 
2118
        hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
 
2119
        data->hpaned = hpaned;
 
2120
        gtk_paned_pack1 (GTK_PANED(vpaned), hpaned, FALSE, FALSE);
 
2121
 
 
2122
                widget = ui_hub_account_create(data);
3319
2123
                //gtk_widget_set_size_request (widget, 100, -1);
3320
2124
                gtk_paned_pack1 (GTK_PANED(hpaned), widget, FALSE, FALSE);
3321
2125
 
3322
 
                widget = ui_mainwindow_create_topspending(data);
 
2126
                widget = ui_hub_spending_create(data);
3323
2127
                //gtk_widget_set_size_request (widget, -1, 100);
3324
2128
                gtk_paned_pack2 (GTK_PANED(hpaned), widget, TRUE, FALSE);
3325
2129
 
 
2130
        box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 
2131
        data->GR_upc = box;
 
2132
        gtk_paned_pack2 (GTK_PANED(vpaned), box, TRUE, FALSE);
 
2133
 
 
2134
        sidebar = gtk_stack_sidebar_new ();
 
2135
        gtk_box_pack_start (GTK_BOX (box), sidebar, FALSE, FALSE, 0);
 
2136
 
 
2137
        stack = gtk_stack_new ();
 
2138
        //gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
 
2139
        gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
 
2140
        data->stack = stack;
 
2141
    gtk_box_pack_start (GTK_BOX (box), stack, TRUE, TRUE, 0);
 
2142
        
 
2143
                page = ui_hub_scheduled_create(data);
 
2144
                gtk_stack_add_titled (GTK_STACK (stack), page, "sched", _("Scheduled"));
 
2145
                //gtk_paned_pack2 (GTK_PANED(vpaned), widget, TRUE, FALSE);
 
2146
 
 
2147
                page = ui_hub_transaction_create(data, HUB_TXN_TYPE_FUTURE);
 
2148
                gtk_stack_add_titled (GTK_STACK (stack), page, "futur", _("Future"));
 
2149
 
 
2150
                page = ui_hub_transaction_create(data, HUB_TXN_TYPE_REMIND);
 
2151
                gtk_stack_add_titled (GTK_STACK (stack), page, "remin", _("Remind"));
 
2152
        
3326
2153
 
3327
2154
        //setup, init and show window
3328
2155
        wg = &PREFS->wal_wg;
3344
2171
        if(PREFS->wal_vpaned > 0)
3345
2172
                gtk_paned_set_position(GTK_PANED(data->vpaned), PREFS->wal_vpaned);
3346
2173
 
 
2174
        if( PREFS->pnl_list_tab != NULL )
 
2175
                gtk_stack_set_visible_child_name (GTK_STACK(data->stack), PREFS->pnl_list_tab);
 
2176
 
 
2177
        
3347
2178
        //todo: move this elsewhere
3348
2179
        DB( g_print(" - setup stuff\n") );
3349
2180
 
3355
2186
        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), PREFS->wal_toolbar);
3356
2187
        action = gtk_ui_manager_get_action(data->manager, "/MenuBar/ViewMenu/Spending");
3357
2188
        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), PREFS->wal_spending);
3358
 
        action = gtk_ui_manager_get_action(data->manager, "/MenuBar/ViewMenu/Upcoming");
 
2189
        action = gtk_ui_manager_get_action(data->manager, "/MenuBar/ViewMenu/BottomLists");
3359
2190
        gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), PREFS->wal_upcoming);
3360
2191
 
3361
2192
        /* Drag and drop support, set targets to NULL because we add the
3371
2202
        g_signal_connect (G_OBJECT (window), "drag-data-received",
3372
2203
                          G_CALLBACK (ui_mainwindow_drag_data_received), window);
3373
2204
 
3374
 
 
3375
 
 
3376
2205
        //connect all our signals
3377
2206
        DB( g_print(" - connect signals\n") );
3378
2207
 
3379
 
 
3380
2208
        g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_acc)), "changed", G_CALLBACK (ui_mainwindow_selection), NULL);
3381
2209
        g_signal_connect (GTK_TREE_VIEW(data->LV_acc    ), "row-activated", G_CALLBACK (ui_mainwindow_onRowActivated), GINT_TO_POINTER(2));
3382
 
        g_signal_connect (G_OBJECT (data->BT_expandall  ), "clicked"      , G_CALLBACK (ui_panel_accounts_expand_all), NULL);
3383
 
        g_signal_connect (G_OBJECT (data->BT_collapseall), "clicked"      , G_CALLBACK (ui_panel_accounts_collapse_all), NULL);
3384
 
 
3385
 
        g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_upc)), "changed", G_CALLBACK (ui_mainwindow_scheduled_selection_cb), NULL);
3386
 
        g_signal_connect (GTK_TREE_VIEW(data->LV_upc), "row-activated", G_CALLBACK (ui_mainwindow_scheduled_onRowActivated), NULL);
3387
 
        g_signal_connect (G_OBJECT (data->BT_sched_skip), "clicked", G_CALLBACK (ui_mainwindow_scheduled_skip_cb), data);
3388
 
        g_signal_connect (G_OBJECT (data->BT_sched_editpost), "clicked", G_CALLBACK (ui_mainwindow_scheduled_editpost_cb), data);
3389
 
        g_signal_connect (G_OBJECT (data->BT_sched_post), "clicked", G_CALLBACK (ui_mainwindow_scheduled_post_cb), data);
3390
 
        
3391
 
        hbtk_radio_connect (GTK_CONTAINER(data->RA_type), "toggled", G_CALLBACK (ui_mainwindow_populate_topspending), &data);
3392
 
 
3393
 
        g_signal_connect (data->CY_range, "changed", G_CALLBACK (ui_mainwindow_populate_topspending), NULL);
3394
 
 
3395
2210
 
3396
2211
        /* GtkWindow events */
3397
2212
    g_signal_connect (window, "delete-event", G_CALLBACK (ui_mainwindow_dispose), (gpointer)data);