]> Dogcows Code - chaz/homebank/blob - src/rep_stats.c
projects / chaz / homebank / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
import homebank-4.6.3
[chaz/homebank] / src / rep_stats.c
1 /* HomeBank -- Free, easy, personal accounting for everyone.
2 * Copyright (C) 1995-2014 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
21 #include "homebank.h"
22
23 #include "rep_stats.h"
24
25 #include "list_operation.h"
26 #include "gtk-chart.h"
27 #include "gtk-dateentry.h"
28
29 #include "dsp_mainwindow.h"
30 #include "ui-account.h"
31 #include "ui-payee.h"
32 #include "ui-category.h"
33 #include "ui-filter.h"
34
35 /****************************************************************************/
36 /* Debug macros */
37 /****************************************************************************/
38 #define MYDEBUG 0
39
40 #if MYDEBUG
41 #define DB(x) (x);
42 #else
43 #define DB(x);
44 #endif
45
46 /* our global datas */
47 extern struct HomeBank *GLOBALS;
48 extern struct Preferences *PREFS;
49
50
51 /* prototypes */
52 static void ui_repdist_action_viewlist(GtkAction *action, gpointer user_data);
53 static void ui_repdist_action_viewbar(GtkAction *action, gpointer user_data);
54 static void ui_repdist_action_viewpie(GtkAction *action, gpointer user_data);
55 static void ui_repdist_action_detail(GtkAction *action, gpointer user_data);
56 static void ui_repdist_action_legend(GtkAction *action, gpointer user_data);
57 static void ui_repdist_action_rate(GtkAction *action, gpointer user_data);
58 static void ui_repdist_action_filter(GtkAction *action, gpointer user_data);
59 static void ui_repdist_action_refresh(GtkAction *action, gpointer user_data);
60 static void ui_repdist_action_export(GtkAction *action, gpointer user_data);
61
62
63 static GtkActionEntry entries[] = {
64 { "List" , "hb-view-list" , N_("List") , NULL, N_("View results as list"), G_CALLBACK (ui_repdist_action_viewlist) },
65 { "Bar" , "hb-view-bar" , N_("Bar") , NULL, N_("View results as bars"), G_CALLBACK (ui_repdist_action_viewbar) },
66 { "Pie" , "hb-view-pie" , N_("Pie") , NULL, N_("View results as pies"), G_CALLBACK (ui_repdist_action_viewpie) },
67
68 { "Filter" , "hb-filter" , N_("Filter") , NULL, N_("Edit the filter"), G_CALLBACK (ui_repdist_action_filter) },
69 { "Refresh" , GTK_STOCK_REFRESH , N_("Refresh"), NULL, N_("Refresh results"), G_CALLBACK (ui_repdist_action_refresh) },
70
71 { "Export" , "hb-file-export", N_("Export") , NULL, N_("Export as CSV"), G_CALLBACK (ui_repdist_action_export) },
72 };
73 static guint n_entries = G_N_ELEMENTS (entries);
74
75
76 static GtkToggleActionEntry toggle_entries[] = {
77 { "Detail", "hb-ope-show", /* name, stock id */
78 N_("Detail"), NULL, /* label, accelerator */
79 N_("Toggle detail"), /* tooltip */
80 G_CALLBACK (ui_repdist_action_detail),
81 FALSE }, /* is_active */
82
83 { "Legend", "hb-legend", /* name, stock id */
84 N_("Legend"), NULL, /* label, accelerator */
85 N_("Toggle legend"), /* tooltip */
86 G_CALLBACK (ui_repdist_action_legend),
87 TRUE }, /* is_active */
88
89 { "Rate", "hb-rate", /* name, stock id */
90 N_("Rate"), NULL, /* label, accelerator */
91 N_("Toggle rate"), /* tooltip */
92 G_CALLBACK (ui_repdist_action_rate),
93 FALSE }, /* is_active */
94
95 };
96 static guint n_toggle_entries = G_N_ELEMENTS (toggle_entries);
97
98
99
100 static const gchar *ui_info =
101 "<ui>"
102 " <toolbar name='ToolBar'>"
103 " <toolitem action='List'/>"
104 " <toolitem action='Bar'/>"
105 " <toolitem action='Pie'/>"
106 " <separator/>"
107 " <toolitem action='Detail'/>"
108 " <toolitem action='Legend'/>"
109 " <toolitem action='Rate'/>"
110 " <separator/>"
111 " <toolitem action='Filter'/>"
112 " <toolitem action='Refresh'/>"
113 " <separator/>"
114 " <toolitem action='Export'/>"
115 " </toolbar>"
116 "</ui>";
117
118
119
120 static void ui_repdist_date_change(GtkWidget *widget, gpointer user_data);
121 static void ui_repdist_range_change(GtkWidget *widget, gpointer user_data);
122 static void ui_repdist_detail(GtkWidget *widget, gpointer user_data);
123 static void ui_repdist_update(GtkWidget *widget, gpointer user_data);
124 static void ui_repdist_update_total(GtkWidget *widget, gpointer user_data);
125 static void ui_repdist_export_csv(GtkWidget *widget, gpointer user_data);
126 static void ui_repdist_compute(GtkWidget *widget, gpointer user_data);
127 static void ui_repdist_sensitive(GtkWidget *widget, gpointer user_data);
128 static void ui_repdist_toggle_detail(GtkWidget *widget, gpointer user_data);
129 static void ui_repdist_toggle_legend(GtkWidget *widget, gpointer user_data);
130 static void ui_repdist_toggle_minor(GtkWidget *widget, gpointer user_data);
131 static void ui_repdist_toggle_rate(GtkWidget *widget, gpointer user_data);
132 static GtkWidget *ui_list_repdist_create(void);
133 static void ui_repdist_update_daterange(GtkWidget *widget, gpointer user_data);
134
135 static gint ui_list_repdist_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata);
136
137
138
139 gchar *CYA_STATSELECT[] = {
140 N_("Category"),
141 N_("Subcategory"),
142 N_("Payee"),
143 N_("Tag"),
144 N_("Month"),
145 N_("Year"),
146 NULL
147 };
148
149 gchar *CYA_KIND2[] = {
150 N_("Exp. & Inc."),
151 N_("Expense"),
152 N_("Income"),
153 N_("Balance"),
154 NULL
155 };
156
157
158 //extern gchar *CYA_FLT_SELECT[];
159
160 gchar *CYA_MONTHS[] =
161 {
162 N_("January"),
163 N_("February"),
164 N_("March"),
165 N_("April"),
166 N_("May"),
167 N_("June"),
168 N_("July"),
169 N_("August"),
170 N_("September"),
171 N_("October"),
172 N_("November"),
173 N_("December"),
174 NULL
175 };
176
177 /* action functions -------------------- */
178
179 static void ui_repdist_action_viewlist(GtkAction *action, gpointer user_data)
180 {
181 struct ui_repdist_data *data = user_data;
182
183 gtk_notebook_set_current_page(GTK_NOTEBOOK(data->GR_result), 0);
184 ui_repdist_sensitive(data->window, NULL);
185 }
186
187 static void ui_repdist_action_viewbar(GtkAction *action, gpointer user_data)
188 {
189 struct ui_repdist_data *data = user_data;
190
191 gtk_notebook_set_current_page(GTK_NOTEBOOK(data->GR_result), 1);
192 gtk_chart_set_type (GTK_CHART(data->RE_chart), CHART_TYPE_COL);
193 ui_repdist_sensitive(data->window, NULL);
194 }
195
196 static void ui_repdist_action_viewpie(GtkAction *action, gpointer user_data)
197 {
198 struct ui_repdist_data *data = user_data;
199 gint tmpview;
200
201 gtk_notebook_set_current_page(GTK_NOTEBOOK(data->GR_result), 1);
202
203 gtk_chart_set_type (GTK_CHART(data->RE_chart), CHART_TYPE_PIE);
204 ui_repdist_sensitive(data->window, NULL);
205
206 tmpview = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_view));
207
208 // ensure not exp & inc for piechart
209 if( tmpview == 0 )
210 {
211 //g_signal_handler_block(data->CY_view, data->handler_id[HID_REPDIST_VIEW]);
212 gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_view), 1);
213 //g_signal_handler_unblock(data->CY_view, data->handler_id[HID_REPDIST_VIEW]);
214 }
215
216 }
217
218 static void ui_repdist_action_detail(GtkAction *action, gpointer user_data)
219 {
220 struct ui_repdist_data *data = user_data;
221
222 ui_repdist_toggle_detail(data->window, NULL);
223 }
224
225 static void ui_repdist_action_legend(GtkAction *action, gpointer user_data)
226 {
227 struct ui_repdist_data *data = user_data;
228
229 ui_repdist_toggle_legend(data->window, NULL);
230 }
231
232 static void ui_repdist_action_rate(GtkAction *action, gpointer user_data)
233 {
234 struct ui_repdist_data *data = user_data;
235
236 ui_repdist_toggle_rate(data->window, NULL);
237 }
238
239 static void ui_repdist_action_filter(GtkAction *action, gpointer user_data)
240 {
241 struct ui_repdist_data *data = user_data;
242
243 //debug
244 //create_deffilter_window(data->filter, TRUE);
245
246 if(ui_flt_manage_dialog_new(data->filter, TRUE) != GTK_RESPONSE_REJECT)
247 {
248 ui_repdist_compute(data->window, NULL);
249 ui_repdist_update_daterange(data->window, NULL);
250 }
251 }
252
253 static void ui_repdist_action_refresh(GtkAction *action, gpointer user_data)
254 {
255 struct ui_repdist_data *data = user_data;
256
257 ui_repdist_compute(data->window, NULL);
258 }
259
260 static void ui_repdist_action_export(GtkAction *action, gpointer user_data)
261 {
262 struct ui_repdist_data *data = user_data;
263
264 ui_repdist_export_csv(data->window, NULL);
265 }
266
267
268
269 /* ======================== */
270
271
272
273 /*
274 ** ============================================================================
275 */
276
277
278
279
280 /*
281 ** return the month list position correponding to the passed date
282 */
283 static gint DateInPer(guint32 from, guint32 opedate)
284 {
285 GDate *date1, *date2;
286 gint pos;
287
288 //debug
289 // this return sometimes -1, -2 which is wrong
290
291 date1 = g_date_new_julian(from);
292 date2 = g_date_new_julian(opedate);
293
294 pos = ((g_date_get_year(date2) - g_date_get_year(date1)) * 12) + g_date_get_month(date2) - g_date_get_month(date1);
295
296 //g_print(" from=%d-%d ope=%d-%d => %d\n", g_date_get_month(date1), g_date_get_year(date1), g_date_get_month(date2), g_date_get_year(date2), pos);
297
298 g_date_free(date2);
299 g_date_free(date1);
300
301 return(pos);
302 }
303
304 /*
305 ** return the year list position correponding to the passed date
306 */
307 static gint DateInYear(guint32 from, guint32 opedate)
308 {
309 GDate *date;
310 gint year_from, year_ope, pos;
311
312 date = g_date_new_julian(from);
313 year_from = g_date_get_year(date);
314 g_date_set_julian(date, opedate);
315 year_ope = g_date_get_year(date);
316 g_date_free(date);
317
318 pos = year_ope - year_from;
319
320 //g_print(" from=%d ope=%d => %d\n", year_from, year_ope, pos);
321
322 return(pos);
323 }
324
325 static void ui_repdist_date_change(GtkWidget *widget, gpointer user_data)
326 {
327 struct ui_repdist_data *data;
328
329 DB( g_print("\n[repdist] date change\n") );
330
331 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
332
333 data->filter->mindate = gtk_dateentry_get_date(GTK_DATE_ENTRY(data->PO_mindate));
334 data->filter->maxdate = gtk_dateentry_get_date(GTK_DATE_ENTRY(data->PO_maxdate));
335
336 // set min/max date for both widget
337 gtk_dateentry_set_maxdate(GTK_DATE_ENTRY(data->PO_mindate), data->filter->maxdate);
338 gtk_dateentry_set_mindate(GTK_DATE_ENTRY(data->PO_maxdate), data->filter->mindate);
339
340 g_signal_handler_block(data->CY_range, data->handler_id[HID_REPDIST_RANGE]);
341 gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_range), FLT_RANGE_OTHER);
342 g_signal_handler_unblock(data->CY_range, data->handler_id[HID_REPDIST_RANGE]);
343
344
345 ui_repdist_compute(widget, NULL);
346 ui_repdist_update_daterange(widget, NULL);
347
348 }
349
350
351
352 static void ui_repdist_range_change(GtkWidget *widget, gpointer user_data)
353 {
354 struct ui_repdist_data *data;
355 gint range;
356
357 DB( g_print("\n[repdist] range change\n") );
358
359 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
360
361 range = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_range));
362
363 if(range != FLT_RANGE_OTHER)
364 {
365 filter_preset_daterange_set(data->filter, range);
366
367 g_signal_handler_block(data->PO_mindate, data->handler_id[HID_REPDIST_MINDATE]);
368 g_signal_handler_block(data->PO_maxdate, data->handler_id[HID_REPDIST_MAXDATE]);
369
370 gtk_dateentry_set_date(GTK_DATE_ENTRY(data->PO_mindate), data->filter->mindate);
371 gtk_dateentry_set_date(GTK_DATE_ENTRY(data->PO_maxdate), data->filter->maxdate);
372
373 g_signal_handler_unblock(data->PO_mindate, data->handler_id[HID_REPDIST_MINDATE]);
374 g_signal_handler_unblock(data->PO_maxdate, data->handler_id[HID_REPDIST_MAXDATE]);
375
376 ui_repdist_compute(widget, NULL);
377 ui_repdist_update_daterange(widget, NULL);
378 }
379 else
380 {
381 if(ui_flt_manage_dialog_new(data->filter, TRUE) != GTK_RESPONSE_REJECT)
382 {
383 ui_repdist_compute(data->window, NULL);
384 ui_repdist_update_daterange(widget, NULL);
385 }
386 }
387 }
388
389
390
391 static gint ui_repdist_result_get_pos(gint tmpfor, guint from, Transaction *ope)
392 {
393 gint pos = 0;
394
395 switch(tmpfor)
396 {
397 case BY_REPDIST_CATEGORY:
398 {
399 Category *catentry = da_cat_get(ope->kcat);
400 if(catentry)
401 pos = (catentry->flags & GF_SUB) ? catentry->parent : catentry->key;
402 }
403 break;
404 case BY_REPDIST_SUBCATEGORY:
405 pos = ope->kcat;
406 break;
407 case BY_REPDIST_PAYEE:
408 pos = ope->kpay;
409 break;
410 case BY_REPDIST_MONTH:
411 pos = DateInPer(from, ope->date);
412 break;
413 case BY_REPDIST_YEAR:
414 pos = DateInYear(from, ope->date);
415 break;
416 }
417 return pos;
418 }
419
420
421
422
423 static void ui_repdist_detail(GtkWidget *widget, gpointer user_data)
424 {
425 struct ui_repdist_data *data;
426 guint active = GPOINTER_TO_INT(user_data);
427 guint tmpfor;
428 GList *list;
429 GtkTreeModel *model;
430 GtkTreeIter iter;
431
432 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
433
434 DB( g_print("\n[repdist] detail\n") );
435
436 /* clear and detach our model */
437 model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_detail));
438 gtk_list_store_clear (GTK_LIST_STORE(model));
439
440 if(data->detail)
441 {
442 tmpfor = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_by));
443
444 g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
445 gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_detail), NULL); /* Detach model from view */
446
447 /* fill in the model */
448 list = g_list_first(GLOBALS->ope_list);
449 while (list != NULL)
450 {
451 Transaction *ope = list->data;
452 Account *acc;
453
454 //DB( g_print(" get %s\n", ope->ope_Word) );
455
456 acc = da_acc_get(ope->kacc);
457 if(acc == NULL) goto next1;
458 if((acc->flags & (AF_CLOSED|AF_NOREPORT))) goto next1;
459
460 //filter here
461 if( !(ope->flags & OF_REMIND) )
462 {
463 if(filter_test(data->filter, ope) == 1)
464 {
465 guint i, pos = 0;
466
467 if( tmpfor != BY_REPDIST_TAG )
468 {
469 if( (tmpfor == BY_REPDIST_CATEGORY || tmpfor == BY_REPDIST_SUBCATEGORY) && ope->flags & OF_SPLIT )
470 {
471 guint nbsplit = da_transaction_splits_count(ope);
472 Split *split;
473
474 for(i=0;i<nbsplit;i++)
475 {
476 split = ope->splits[i];
477 switch(tmpfor)
478 {
479 case BY_REPDIST_CATEGORY:
480 {
481 Category *catentry = da_cat_get(split->kcat);
482 if(catentry)
483 pos = (catentry->flags & GF_SUB) ? catentry->parent : catentry->key;
484 }
485 break;
486 case BY_REPDIST_SUBCATEGORY:
487 pos = split->kcat;
488 break;
489 }
490
491 if( pos == active )
492 {
493
494 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
495 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
496 LST_DSPOPE_DATAS, ope,
497 -1);
498
499 break;
500 }
501
502 }
503 }
504 else
505 {
506 pos = ui_repdist_result_get_pos(tmpfor, data->filter->mindate, ope);
507 if( pos == active )
508 {
509
510 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
511 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
512 LST_DSPOPE_DATAS, ope,
513 -1);
514
515 }
516 }
517
518 }
519 else
520 /* the TAG process is particular */
521 {
522 if(ope->tags != NULL)
523 {
524 guint32 *tptr = ope->tags;
525
526 while(*tptr)
527 {
528 pos = *tptr - 1;
529
530 DB( g_print(" -> storing tag %d %.2f\n", pos, ope->amount) );
531
532 if( pos == active )
533 {
534 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
535 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
536 LST_DSPOPE_DATAS, ope,
537 -1);
538
539 }
540
541 tptr++;
542 }
543
544 }
545 }
546
547
548
549 }
550 }
551 next1:
552 list = g_list_next(list);
553 }
554
555 /* Re-attach model to view */
556 gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_detail), model);
557 g_object_unref(model);
558
559 }
560
561 }
562
563
564 static void ui_repdist_update(GtkWidget *widget, gpointer user_data)
565 {
566 struct ui_repdist_data *data;
567 gboolean byamount;
568 GtkTreeModel *model;
569 gint page, tmpfor, tmpkind, column;
570 gboolean xval;
571 gchar *title;
572
573 DB( g_print("\n[repdist] update\n") );
574
575 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
576
577
578 model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_report));
579 byamount = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_byamount));
580 tmpfor = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_by));
581 tmpkind = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_view));
582
583 // ensure not exp & inc for piechart
584 page = gtk_notebook_get_current_page(GTK_NOTEBOOK(data->GR_result));
585
586 if( page == 2 && tmpkind == 0 )
587 {
588 g_signal_handler_block(data->CY_view, data->handler_id[HID_REPDIST_VIEW]);
589 gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_view), 1);
590 g_signal_handler_unblock(data->CY_view, data->handler_id[HID_REPDIST_VIEW]);
591 tmpkind = 1;
592 }
593
594
595 DB( g_print(" tmpkind %d\n\n", tmpkind) );
596
597
598 column = byamount ? LST_REPDIST_EXPENSE+(tmpkind-1)*2 : LST_REPDIST_POS;
599
600 //#833614 sort category/payee by name
601 //if(!byamount && tmpkind <= BY_REPDIST_PAYEE)
602 // column = LST_REPDIST_NAME;
603
604 DB( g_print(" sort on column %d\n\n", column) );
605
606 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), column, GTK_SORT_DESCENDING);
607
608 column = LST_REPDIST_EXPENSE+(tmpkind-1)*2;
609
610 /* set chart color scheme */
611 gtk_chart_set_color_scheme(GTK_CHART(data->RE_chart), PREFS->report_color_scheme);
612
613 /* set chart title */
614 ////TRANSLATORS: example 'Expense by Category'
615 title = g_strdup_printf(_("%s by %s"), _(CYA_KIND2[tmpkind]), _(CYA_STATSELECT[tmpfor]) );
616
617 /* update absolute or not */
618 gboolean abs = (tmpkind == 1 || tmpkind == 2) ? TRUE : FALSE;
619 gtk_chart_set_absolute(GTK_CHART(data->RE_chart), abs);
620
621
622 /* update bar chart */
623 DB( g_print(" set bar to %d %s\n\n", column, _(CYA_KIND2[tmpkind])) );
624 if( tmpkind == 0 )
625 gtk_chart_set_dualdatas(GTK_CHART(data->RE_chart), model, LST_REPDIST_EXPENSE, LST_REPDIST_INCOME, title);
626 else
627 gtk_chart_set_datas(GTK_CHART(data->RE_chart), model, column, title);
628
629
630 /* show xval for month/year and no by amount display */
631 xval = FALSE;
632
633
634 if( !byamount && (tmpfor == BY_REPDIST_MONTH || tmpfor == BY_REPDIST_YEAR) )
635 {
636 xval = TRUE;
637 switch( tmpfor)
638 {
639 case BY_REPDIST_MONTH:
640 gtk_chart_set_every_xval(GTK_CHART(data->RE_chart), 4);
641 break;
642 case BY_REPDIST_YEAR:
643 gtk_chart_set_every_xval(GTK_CHART(data->RE_chart), 2);
644 break;
645 }
646 }
647
648 gtk_chart_show_xval(GTK_CHART(data->RE_chart), xval);
649
650 g_free(title);
651
652 }
653
654 static void ui_repdist_update_daterange(GtkWidget *widget, gpointer user_data)
655 {
656 struct ui_repdist_data *data;
657 gchar *daterange;
658
659 DB( g_print("\n[repdist] update daterange\n") );
660
661 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
662
663 daterange = filter_daterange_text_get(data->filter);
664 gtk_label_set_markup(GTK_LABEL(data->TX_daterange), daterange);
665 g_free(daterange);
666 }
667
668 static void ui_repdist_update_total(GtkWidget *widget, gpointer user_data)
669 {
670 struct ui_repdist_data *data;
671 //gboolean minor;
672
673 DB( g_print("\n[repdist] update total\n") );
674
675 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
676
677 //minor = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_minor));
678
679 /*
680 hb_label_set_colvaluecurr(GTK_LABEL(data->TX_total[0]), data->total_expense, GLOBALS->kcur);
681 hb_label_set_colvaluecurr(GTK_LABEL(data->TX_total[1]), data->total_income, GLOBALS->kcur);
682 hb_label_set_colvaluecurr(GTK_LABEL(data->TX_total[2]), data->total_expense + data->total_income, GLOBALS->kcur);
683 */
684
685 hb_label_set_colvalue(GTK_LABEL(data->TX_total[0]), data->total_expense, GLOBALS->minor);
686 hb_label_set_colvalue(GTK_LABEL(data->TX_total[1]), data->total_income, GLOBALS->minor);
687 hb_label_set_colvalue(GTK_LABEL(data->TX_total[2]), data->total_expense + data->total_income, GLOBALS->minor);
688
689
690 }
691
692 static void ui_repdist_export_csv(GtkWidget *widget, gpointer user_data)
693 {
694 struct ui_repdist_data *data;
695 GtkTreeModel *model;
696 GtkTreeIter iter;
697 gboolean valid;
698 gchar *filename = NULL;
699 GIOChannel *io;
700 gchar *outstr, *name;
701 gint tmpfor;
702
703 DB( g_print("\n[repdist] export csv\n") );
704
705 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
706
707 tmpfor = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_by));
708
709 name = g_strdup_printf("hb-stat_%s.csv", CYA_STATSELECT[tmpfor]);
710
711 if( ui_file_chooser_csv(GTK_WINDOW(data->window), GTK_FILE_CHOOSER_ACTION_SAVE, &filename, name) == TRUE )
712 {
713 DB( g_print(" + filename is %s\n", filename) );
714
715 io = g_io_channel_new_file(filename, "w", NULL);
716 if(io != NULL)
717 {
718 // header
719 outstr = g_strdup_printf("%s;%s;%s;%s\n", _("Result"), _("expense"), _("Income"), _("Balance"));
720 g_io_channel_write_chars(io, outstr, -1, NULL, NULL);
721
722 model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_report));
723 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
724 while (valid)
725 {
726 gchar *name;
727 gdouble exp, inc, bal;
728
729 gtk_tree_model_get (model, &iter,
730 //LST_REPDIST_KEY, i,
731 LST_REPDIST_NAME , &name,
732 LST_REPDIST_EXPENSE, &exp,
733 LST_REPDIST_INCOME , &inc,
734 LST_REPDIST_BALANCE, &bal,
735 -1);
736
737 outstr = g_strdup_printf("%s;%.2f;%.2f;%.2f\n", name, exp, inc, bal);
738 g_io_channel_write_chars(io, outstr, -1, NULL, NULL);
739
740 DB( g_print("%s", outstr) );
741
742 g_free(outstr);
743
744 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
745 }
746
747 g_io_channel_unref (io);
748 }
749
750 g_free( filename );
751 }
752
753 g_free(name);
754
755
756 }
757
758
759 static void ui_repdist_compute(GtkWidget *widget, gpointer user_data)
760 {
761 struct ui_repdist_data *data;
762 gint tmpfor, tmpkind;
763 guint32 from, to;
764 GtkTreeModel *model;
765 GtkTreeIter iter;
766 GList *list, *tmplist = NULL;
767 guint n_result, sortid;
768 guint i;
769 GDate *date1, *date2;
770 gdouble *tmp_income, *tmp_expense;
771 gdouble exprate, incrate, balrate;
772
773 DB( g_print("\n[repdist] compute\n") );
774
775 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
776
777 tmpfor = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_by));
778 tmpkind = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_view));
779
780
781 DB( g_print(" for=%d,kind=%d\n", tmpfor, tmpkind) );
782
783
784
785 /* do nothing if no transaction */
786 if(g_list_length(GLOBALS->ope_list) == 0) return;
787
788 //get our min max date
789 from = data->filter->mindate;
790 to = data->filter->maxdate;
791 if(to < from) return;
792
793 /* count number or results */
794 switch(tmpfor)
795 {
796 case BY_REPDIST_CATEGORY:
797 case BY_REPDIST_SUBCATEGORY:
798 n_result = da_cat_get_max_key() + 1;
799 tmplist = category_glist_sorted(1);
800 break;
801 case BY_REPDIST_PAYEE:
802 n_result = da_pay_get_max_key() + 1;
803 tmplist = payee_glist_sorted(1);
804 break;
805 case BY_REPDIST_TAG:
806 n_result = da_tag_length();
807 tmplist = tag_glist_sorted(1);
808 break;
809 case BY_REPDIST_MONTH:
810 date1 = g_date_new_julian(from);
811 date2 = g_date_new_julian(to);
812 n_result = ((g_date_get_year(date2) - g_date_get_year(date1)) * 12) + g_date_get_month(date2) - g_date_get_month(date1) + 1;
813 g_date_free(date2);
814 g_date_free(date1);
815 break;
816 case BY_REPDIST_YEAR:
817 date1 = g_date_new_julian(from);
818 date2 = g_date_new_julian(to);
819 n_result = g_date_get_year(date2) - g_date_get_year(date1) + 1;
820 g_date_free(date2);
821 g_date_free(date1);
822 break;
823 default:
824 n_result = 0;
825 }
826
827 DB( g_print(" %s :: n_result=%d\n", CYA_STATSELECT[tmpfor], n_result) );
828
829 /* allocate some memory */
830 tmp_expense = g_malloc0((n_result+2) * sizeof(gdouble));
831 tmp_income = g_malloc0((n_result+2) * sizeof(gdouble));
832
833 data->total_expense = 0.0;
834 data->total_income = 0.0;
835
836 if(tmp_expense && tmp_income)
837 {
838 /* compute the results */
839 list = g_list_first(GLOBALS->ope_list);
840 while (list != NULL)
841 {
842 Transaction *ope = list->data;
843 Account *acc;
844 //debug
845 //DB( g_print("** testing '%s', cat=%d==> %d\n", ope->wording, ope->category, filter_test(data->filter, ope)) );
846 acc = da_acc_get(ope->kacc);
847 if(acc == NULL) goto next1;
848 if((acc->flags & (AF_CLOSED|AF_NOREPORT))) goto next1;
849
850 if( !(ope->flags & OF_REMIND) )
851 {
852 if( (filter_test(data->filter, ope) == 1) )
853 {
854 guint32 pos = 0;
855 gdouble trn_amount;
856
857 //trn_amount = to_base_amount(ope->amount, acc->kcur);
858 trn_amount = ope->amount;
859
860 if( tmpfor != BY_REPDIST_TAG )
861 {
862 if( (tmpfor == BY_REPDIST_CATEGORY || tmpfor == BY_REPDIST_SUBCATEGORY) && ope->flags & OF_SPLIT )
863 {
864 guint nbsplit = da_transaction_splits_count(ope);
865 Split *split;
866 Category *catentry;
867 gint sinsert;
868
869 for(i=0;i<nbsplit;i++)
870 {
871 split = ope->splits[i];
872 catentry = da_cat_get(split->kcat);
873 if(!catentry) continue;
874 sinsert = ( catentry->filter == TRUE ) ? 1 : 0;
875 if(data->filter->option[FILTER_CATEGORY] == 2) sinsert ^= 1;
876
877 DB( g_print(" split '%s' insert=%d\n",catentry->name, sinsert) );
878
879 if( (data->filter->option[FILTER_CATEGORY] == 0) || sinsert)
880 {
881 switch(tmpfor)
882 {
883 case BY_REPDIST_CATEGORY:
884 {
885 if(catentry)
886 pos = (catentry->flags & GF_SUB) ? catentry->parent : catentry->key;
887 }
888 break;
889 case BY_REPDIST_SUBCATEGORY:
890 pos = split->kcat;
891 break;
892 }
893
894 //trn_amount = to_base_amount(split->amount, acc->kcur);
895 trn_amount = split->amount;
896
897 if(trn_amount > 0.0)
898 {
899 tmp_income[pos] += trn_amount;
900 data->total_income += trn_amount;
901 }
902 else
903 {
904 tmp_expense[pos] += trn_amount;
905 data->total_expense += trn_amount;
906 }
907
908 }
909 // end insert
910
911 }
912 }
913 else
914 {
915 pos = ui_repdist_result_get_pos(tmpfor, from, ope);
916 if(trn_amount > 0.0)
917 {
918 tmp_income[pos] += trn_amount;
919 data->total_income += trn_amount;
920 }
921 else
922 {
923 tmp_expense[pos] += trn_amount;
924 data->total_expense += trn_amount;
925 }
926 }
927 }
928 else
929 /* the TAG process is particular */
930 {
931 if(ope->tags != NULL)
932 {
933 guint32 *tptr = ope->tags;
934
935 while(*tptr)
936 {
937 pos = *tptr - 1;
938
939 DB( g_print(" -> storing tag %d %s %.2f\n", pos, da_tag_get(*tptr)->name, trn_amount) );
940
941 if(trn_amount > 0.0)
942 {
943 tmp_income[pos] += trn_amount;
944 }
945 else
946 {
947 tmp_expense[pos] += trn_amount;
948 }
949 tptr++;
950 }
951
952 //#1195859
953 if(trn_amount > 0.0)
954 {
955 data->total_income += trn_amount;
956 }
957 else
958 {
959 data->total_expense += trn_amount;
960 }
961
962 }
963 }
964
965 // fix total according to selection
966 //if(tmpkind==0 && !tmp_expense[pos]) { data->total_income -= ope->amount; }
967 //if(tmpkind==1 && !tmp_income[pos] ) { data->total_expense -= ope->amount; }
968
969
970 }
971 }
972 next1:
973 list = g_list_next(list);
974 }
975
976 /* clear and detach our model */
977 model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_report));
978 gtk_list_store_clear (GTK_LIST_STORE(model));
979 g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
980 gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_report), NULL); /* Detach model from view */
981
982 /* insert into the treeview */
983 for(i=0, sortid=0; i<n_result; i++)
984 {
985 gchar *name, *fullcatname;
986 gchar buffer[64];
987 GDate *date;
988
989 name = NULL;
990 fullcatname = NULL;
991
992 DB( g_print("try to insert item %d\n", i) );
993
994
995 /* filter empty results */
996 if(tmpfor == BY_REPDIST_CATEGORY || tmpfor == BY_REPDIST_SUBCATEGORY || tmpfor == BY_REPDIST_PAYEE || tmpfor == BY_REPDIST_TAG)
997 {
998 if( tmpkind == 1 && !tmp_expense[i] ) continue;
999 if( tmpkind == 2 && !tmp_income[i] ) continue;
1000 if( !tmp_expense[i] && !tmp_income[i] ) continue;
1001 }
1002
1003 /* get the result name */
1004 switch(tmpfor)
1005 {
1006 case BY_REPDIST_CATEGORY:
1007 {
1008 Category *entry = da_cat_get(i);
1009
1010 if(entry != NULL)
1011 {
1012 name = entry->key == 0 ? _("(no category)") : entry->name;
1013
1014 sortid = g_list_index(tmplist, entry);
1015 }
1016 }
1017 break;
1018
1019 case BY_REPDIST_SUBCATEGORY:
1020 {
1021 Category *entry = da_cat_get(i);
1022 if(entry != NULL)
1023 {
1024 if(entry->flags & GF_SUB)
1025 {
1026 Category *parent = da_cat_get(entry->parent);
1027
1028 fullcatname = g_strdup_printf("%s : %s", parent->name, entry->name);
1029 name = fullcatname;
1030 }
1031 else
1032 name = entry->key == 0 ? _("(no category)") : entry->name;
1033
1034 sortid = g_list_index(tmplist, entry);
1035 }
1036 }
1037 break;
1038
1039 case BY_REPDIST_PAYEE:
1040 {
1041 Payee *entry = da_pay_get(i);
1042 if(entry != NULL)
1043 {
1044 name = entry->key == 0 ? _("(no payee)") : entry->name;
1045 sortid = g_list_index(tmplist, entry);
1046 }
1047 }
1048 break;
1049
1050 case BY_REPDIST_TAG:
1051 {
1052 Tag *entry = da_tag_get(i+1);
1053 name = entry->name;
1054 sortid = g_list_index(tmplist, entry);
1055 }
1056 break;
1057
1058 case BY_REPDIST_MONTH:
1059 date = g_date_new_julian(from);
1060 g_date_add_months(date, i);
1061 //g_snprintf(buffer, 63, "%d-%02d", g_date_get_year(date), g_date_get_month(date));
1062 g_snprintf(buffer, 63, "%d-%s", g_date_get_year(date), _(CYA_MONTHS[g_date_get_month(date)-1]));
1063 g_date_free(date);
1064 name = buffer;
1065 break;
1066
1067 case BY_REPDIST_YEAR:
1068 date = g_date_new_julian(from);
1069 g_date_add_years(date, i);
1070 g_snprintf(buffer, 63, "%d", g_date_get_year(date));
1071 g_date_free(date);
1072 name = buffer;
1073 break;
1074 }
1075
1076 DB( g_print(" inserting %2d, '%s', %9.2f %9.2f %9.2f\n", i, name, tmp_expense[i], tmp_income[i], tmp_expense[i] + tmp_income[i]) );
1077
1078 //compute rate
1079 exprate = 0.0;
1080 incrate = 0.0;
1081 balrate = 0.0;
1082
1083 if( data->total_expense )
1084 exprate = ABS((tmp_expense[i] * 100 / data->total_expense));
1085
1086 if( data->total_income )
1087 incrate = (tmp_income[i] * 100 / data->total_income);
1088
1089 data->total_balance = ABS(data->total_expense) + data->total_income;
1090 if( data->total_balance )
1091 balrate = (ABS(tmp_expense[i]) + tmp_income[i]) * 100 / data->total_balance;
1092
1093 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
1094 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
1095 LST_REPDIST_POS, sortid++,
1096 LST_REPDIST_KEY, i,
1097 LST_REPDIST_NAME, name,
1098 LST_REPDIST_EXPENSE, tmp_expense[i],
1099 LST_REPDIST_INCOME , tmp_income[i],
1100 LST_REPDIST_BALANCE, tmp_expense[i] + tmp_income[i],
1101 LST_REPDIST_EXPRATE, exprate,
1102 LST_REPDIST_INCRATE, incrate,
1103 LST_REPDIST_BALRATE, balrate,
1104 -1);
1105
1106 g_free(fullcatname);
1107 }
1108
1109 gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_report));
1110
1111 /* Re-attach model to view */
1112 gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_report), model);
1113 g_object_unref(model);
1114 }
1115
1116 /* free our memory */
1117 g_free(tmp_expense);
1118 g_free(tmp_income);
1119
1120 /* free tmplist (sort cat/pay) */
1121 g_list_free(tmplist);
1122
1123 ui_repdist_update_total(widget,NULL);
1124
1125 ui_repdist_update(widget, user_data);
1126
1127 }
1128
1129
1130
1131
1132
1133 /*
1134 ** update sensitivity
1135 */
1136 static void ui_repdist_sensitive(GtkWidget *widget, gpointer user_data)
1137 {
1138 struct ui_repdist_data *data;
1139 gboolean active;
1140 gboolean sensitive;
1141 gint page;
1142
1143 DB( g_print("\n[repdist] sensitive\n") );
1144
1145 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1146
1147 active = gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_report)), NULL, NULL);
1148
1149 page = gtk_notebook_get_current_page(GTK_NOTEBOOK(data->GR_result));
1150
1151 sensitive = page == 0 ? active : FALSE;
1152 // gtk_widget_set_sensitive(data->TB_buttons[ACTION_REPBUDGET_DETAIL], sensitive);
1153 gtk_action_set_sensitive(gtk_ui_manager_get_action(data->ui, "/ToolBar/Detail"), sensitive);
1154
1155 //view = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_view));
1156
1157
1158
1159 sensitive = page == 0 ? FALSE : TRUE;
1160 gtk_widget_set_sensitive(data->RG_zoomx, sensitive);
1161 // gtk_widget_set_sensitive(data->TB_buttons[ACTION_REPBUDGET_LEGEND], sensitive);
1162 gtk_action_set_sensitive(gtk_ui_manager_get_action(data->ui, "/ToolBar/Legend"), sensitive);
1163
1164 sensitive = page == 0 ? TRUE : FALSE;
1165 gtk_action_set_sensitive(gtk_ui_manager_get_action(data->ui, "/ToolBar/Rate"), sensitive);
1166
1167
1168 }
1169
1170 static void ui_repdist_update_detail(GtkWidget *widget, gpointer user_data)
1171 {
1172 struct ui_repdist_data *data;
1173
1174 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1175
1176 if(GTK_IS_TREE_VIEW(data->LV_report))
1177 {
1178 if(data->detail)
1179 {
1180 GtkTreeSelection *treeselection;
1181 GtkTreeModel *model;
1182 GtkTreeIter iter;
1183 guint key;
1184
1185 treeselection = gtk_tree_view_get_selection (GTK_TREE_VIEW(data->LV_report));
1186
1187 if (gtk_tree_selection_get_selected(treeselection, &model, &iter))
1188 {
1189 gtk_tree_model_get(model, &iter, LST_REPDIST_KEY, &key, -1);
1190
1191 DB( g_print(" - active is %d\n", key) );
1192
1193 ui_repdist_detail(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), GINT_TO_POINTER(key));
1194 }
1195
1196
1197
1198 gtk_widget_show(data->GR_detail);
1199 }
1200 else
1201 gtk_widget_hide(data->GR_detail);
1202
1203 }
1204 }
1205
1206
1207
1208
1209 static void ui_repdist_toggle_detail(GtkWidget *widget, gpointer user_data)
1210 {
1211 struct ui_repdist_data *data;
1212
1213 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1214
1215 data->detail ^= 1;
1216
1217 DB( printf("\n[repdist] toggledetail to %d\n", data->detail) );
1218
1219 ui_repdist_update_detail(widget, user_data);
1220
1221 }
1222
1223 /*
1224 ** change the chart legend visibility
1225 */
1226 static void ui_repdist_toggle_legend(GtkWidget *widget, gpointer user_data)
1227 {
1228 struct ui_repdist_data *data;
1229 //gint active;
1230
1231 DB( g_print("\n[repdist] toggle legend\n") );
1232
1233 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1234
1235 data->legend ^= 1;
1236
1237 gtk_chart_show_legend(GTK_CHART(data->RE_chart), data->legend, FALSE);
1238
1239 }
1240
1241 static void ui_repdist_zoomx_callback(GtkWidget *widget, gpointer user_data)
1242 {
1243 struct ui_repdist_data *data;
1244 gdouble value;
1245
1246 DB( g_print("\n[repdist] zoomx\n") );
1247
1248 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1249
1250 value = gtk_range_get_value(GTK_RANGE(data->RG_zoomx));
1251
1252 DB( g_print(" + scale is %.2f\n", value) );
1253
1254 gtk_chart_set_barw(GTK_CHART(data->RE_chart), value);
1255
1256 }
1257
1258
1259 /*
1260 ** change the chart rate columns visibility
1261 */
1262 static void ui_repdist_toggle_rate(GtkWidget *widget, gpointer user_data)
1263 {
1264 struct ui_repdist_data *data;
1265 GtkTreeViewColumn *column;
1266
1267 DB( g_print("\n[repdist] toggle rate\n") );
1268
1269 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1270
1271 data->rate ^= 1;
1272
1273 if(GTK_IS_TREE_VIEW(data->LV_report))
1274 {
1275
1276 column = gtk_tree_view_get_column (GTK_TREE_VIEW(data->LV_report), 2);
1277 gtk_tree_view_column_set_visible(column, data->rate);
1278
1279 column = gtk_tree_view_get_column (GTK_TREE_VIEW(data->LV_report), 4);
1280 gtk_tree_view_column_set_visible(column, data->rate);
1281
1282 column = gtk_tree_view_get_column (GTK_TREE_VIEW(data->LV_report), 6);
1283 gtk_tree_view_column_set_visible(column, data->rate);
1284 }
1285
1286 }
1287
1288 static void ui_repdist_toggle_minor(GtkWidget *widget, gpointer user_data)
1289 {
1290 struct ui_repdist_data *data;
1291
1292 DB( g_print("\n[repdist] toggle minor\n") );
1293
1294 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1295
1296 GLOBALS->minor = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_minor));
1297
1298 ui_repdist_update_total(widget,NULL);
1299
1300 //hbfile_update(data->LV_acc, (gpointer)4);
1301 gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_report));
1302 gtk_chart_show_minor(GTK_CHART(data->RE_chart), GLOBALS->minor);
1303
1304 }
1305
1306
1307 /*
1308 **
1309 */
1310 static void ui_repdist_setup(struct ui_repdist_data *data)
1311 {
1312 DB( g_print("\n[repdist] setup\n") );
1313
1314 data->detail = PREFS->stat_showdetail;
1315 data->legend = 1;
1316 data->rate = PREFS->stat_showrate^1;
1317
1318
1319 ui_repdist_toggle_rate(data->window, NULL);
1320
1321
1322 data->filter = da_filter_malloc();
1323 filter_default_all_set(data->filter);
1324
1325 /* 3.4 : make int transfer out of stats */
1326 data->filter->option[FILTER_PAYMODE] = 1;
1327 data->filter->paymode[PAYMODE_INTXFER] = FALSE;
1328
1329 filter_preset_daterange_set(data->filter, PREFS->date_range_rep);
1330
1331 g_signal_handler_block(data->PO_mindate, data->handler_id[HID_REPDIST_MINDATE]);
1332 g_signal_handler_block(data->PO_maxdate, data->handler_id[HID_REPDIST_MAXDATE]);
1333
1334 gtk_dateentry_set_date(GTK_DATE_ENTRY(data->PO_mindate), data->filter->mindate);
1335 gtk_dateentry_set_date(GTK_DATE_ENTRY(data->PO_maxdate), data->filter->maxdate);
1336
1337 g_signal_handler_unblock(data->PO_mindate, data->handler_id[HID_REPDIST_MINDATE]);
1338 g_signal_handler_unblock(data->PO_maxdate, data->handler_id[HID_REPDIST_MAXDATE]);
1339
1340 }
1341
1342
1343
1344 static void ui_repdist_selection(GtkTreeSelection *treeselection, gpointer user_data)
1345 {
1346 GtkTreeModel *model;
1347 GtkTreeIter iter;
1348 guint key = -1;
1349
1350 DB( g_print("\n[repdist] selection\n") );
1351
1352 if (gtk_tree_selection_get_selected(treeselection, &model, &iter))
1353 {
1354 gtk_tree_model_get(model, &iter, LST_REPDIST_KEY, &key, -1);
1355
1356 }
1357
1358 DB( g_print(" - active is %d\n", key) );
1359
1360 ui_repdist_detail(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), GINT_TO_POINTER(key));
1361 ui_repdist_sensitive(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
1362 }
1363
1364
1365 /*
1366 **
1367 */
1368 static gboolean ui_repdist_dispose(GtkWidget *widget, GdkEvent *event, gpointer user_data)
1369 {
1370 struct ui_repdist_data *data = user_data;
1371 struct WinGeometry *wg;
1372
1373 DB( g_print("\n[repdist] dispose\n") );
1374
1375 da_filter_free(data->filter);
1376
1377 g_free(data);
1378
1379 //store position and size
1380 wg = &PREFS->sta_wg;
1381 gtk_window_get_position(GTK_WINDOW(widget), &wg->l, &wg->t);
1382 gtk_window_get_size(GTK_WINDOW(widget), &wg->w, &wg->h);
1383
1384 DB( g_print(" window: l=%d, t=%d, w=%d, h=%d\n", wg->l, wg->t, wg->w, wg->h) );
1385
1386
1387
1388 //enable define windows
1389 GLOBALS->define_off--;
1390 ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_SENSITIVE));
1391
1392 return FALSE;
1393 }
1394
1395 // the window creation
1396 GtkWidget *ui_repdist_window_new(void)
1397 {
1398 struct ui_repdist_data *data;
1399 struct WinGeometry *wg;
1400 GtkWidget *window, *mainvbox, *hbox, *vbox, *notebook, *treeview;
1401 GtkWidget *label, *widget, *table, *alignment, *entry;
1402 gint row;
1403 GtkUIManager *ui;
1404 GtkActionGroup *actions;
1405 GtkAction *action;
1406 GError *error = NULL;
1407
1408 DB( g_print("\n[repdist] new\n") );
1409
1410
1411 data = g_malloc0(sizeof(struct ui_repdist_data));
1412 if(!data) return NULL;
1413
1414 //disable define windows
1415 GLOBALS->define_off++;
1416 ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(2));
1417
1418 /* create window, etc */
1419 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1420 data->window = window;
1421
1422 //store our window private data
1423 g_object_set_data(G_OBJECT(window), "inst_data", (gpointer)data);
1424
1425 gtk_window_set_title (GTK_WINDOW (window), _("Statistics Report"));
1426
1427 //set the window icon
1428 //homebank_window_set_icon_from_file(GTK_WINDOW (window), "report_stats.svg");
1429 gtk_window_set_icon_name(GTK_WINDOW (window), HB_STOCK_REP_STATS);
1430
1431
1432 //window contents
1433 mainvbox = gtk_vbox_new (FALSE, 0);
1434 gtk_container_add (GTK_CONTAINER (window), mainvbox);
1435
1436 hbox = gtk_hbox_new(FALSE, 0);
1437 gtk_box_pack_start (GTK_BOX (mainvbox), hbox, TRUE, TRUE, 0);
1438
1439 //control part
1440 table = gtk_table_new (6, 3, FALSE);
1441 // gtk_alignment_new(xalign, yalign, xscale, yscale)
1442 alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
1443 gtk_container_add(GTK_CONTAINER(alignment), table);
1444 gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, FALSE, 0);
1445
1446 gtk_container_set_border_width (GTK_CONTAINER (table), HB_BOX_SPACING);
1447 gtk_table_set_row_spacings (GTK_TABLE (table), HB_TABROW_SPACING);
1448 gtk_table_set_col_spacings (GTK_TABLE (table), HB_TABCOL_SPACING);
1449
1450 row = 0;
1451 label = make_label(_("Display"), 0.0, 0.5);
1452 gimp_label_set_attributes(GTK_LABEL(label), PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1);
1453 gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 3, row, row+1);
1454
1455 row++;
1456 label = make_label(_("_View:"), 0, 0.5);
1457 gtk_table_attach (GTK_TABLE (table), label, 1, 2, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
1458 widget = make_cycle(label, CYA_KIND2);
1459 data->CY_view = widget;
1460 gtk_table_attach_defaults (GTK_TABLE (table), widget, 2, 3, row, row+1);
1461
1462 row++;
1463 label = make_label(_("_By:"), 0, 0.5);
1464 gtk_table_attach (GTK_TABLE (table), label, 1, 2, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
1465 widget = make_cycle(label, CYA_STATSELECT);
1466 data->CY_by = widget;
1467 gtk_table_attach_defaults (GTK_TABLE (table), data->CY_by, 2, 3, row, row+1);
1468
1469 row++;
1470 widget = gtk_check_button_new_with_mnemonic (_("By _amount"));
1471 data->CM_byamount = widget;
1472 gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 3, row, row+1);
1473
1474 row++;
1475 widget = gtk_check_button_new_with_mnemonic (_("_Minor currency"));
1476 data->CM_minor = widget;
1477 gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 3, row, row+1);
1478
1479
1480 row++;
1481 label = make_label(_("_Zoom X:"), 0, 0.5);
1482 gtk_table_attach (GTK_TABLE (table), label, 1, 2, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
1483 widget = make_scale(label);
1484 data->RG_zoomx = widget;
1485 gtk_table_attach_defaults (GTK_TABLE (table), widget, 2, 3, row, row+1);
1486
1487
1488 /*
1489 row++;
1490 widget = gtk_check_button_new_with_mnemonic ("Legend");
1491 data->CM_legend = widget;
1492 gtk_table_attach_defaults (GTK_TABLE (table), widget, 1, 2, row, row+1);
1493 */
1494 row++;
1495 widget = gtk_hseparator_new();
1496 gtk_table_attach_defaults (GTK_TABLE (table), widget, 0, 3, row, row+1);
1497
1498 row++;
1499 label = make_label(_("Date filter"), 0.0, 0.5);
1500 gimp_label_set_attributes(GTK_LABEL(label), PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1);
1501 gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 3, row, row+1);
1502
1503 row++;
1504 label = make_label(_("_Range:"), 0, 0.5);
1505 gtk_table_attach (GTK_TABLE (table), label, 1, 2, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
1506 data->CY_range = make_daterange(label, TRUE);
1507 gtk_table_attach_defaults (GTK_TABLE (table), data->CY_range, 2, 3, row, row+1);
1508
1509 row++;
1510 label = make_label(_("_From:"), 0, 0.5);
1511 gtk_table_attach (GTK_TABLE (table), label, 1, 2, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
1512 data->PO_mindate = gtk_dateentry_new();
1513 gtk_table_attach_defaults (GTK_TABLE (table), data->PO_mindate, 2, 3, row, row+1);
1514
1515 row++;
1516 label = make_label(_("_To:"), 0, 0.5);
1517 gtk_table_attach (GTK_TABLE (table), label, 1, 2, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
1518 data->PO_maxdate = gtk_dateentry_new();
1519 gtk_table_attach_defaults (GTK_TABLE (table), data->PO_maxdate, 2, 3, row, row+1);
1520
1521 //part: info + report
1522 vbox = gtk_vbox_new (FALSE, 0);
1523 gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1524
1525 //ui manager
1526 actions = gtk_action_group_new ("Account");
1527
1528 //as we use gettext
1529 gtk_action_group_set_translation_domain(actions, GETTEXT_PACKAGE);
1530
1531 // data to action callbacks is set here (data)
1532 gtk_action_group_add_actions (actions, entries, n_entries, data);
1533
1534 gtk_action_group_add_toggle_actions (actions,
1535 toggle_entries, n_toggle_entries,
1536 data);
1537
1538
1539 /* set which action should have priority in the toolbar */
1540 action = gtk_action_group_get_action(actions, "List");
1541 g_object_set(action, "is_important", TRUE, NULL);
1542
1543 action = gtk_action_group_get_action(actions, "Bar");
1544 g_object_set(action, "is_important", TRUE, NULL);
1545
1546 action = gtk_action_group_get_action(actions, "Pie");
1547 g_object_set(action, "is_important", TRUE, NULL);
1548
1549 action = gtk_action_group_get_action(actions, "Detail");
1550 g_object_set(action, "is_important", TRUE, NULL);
1551 g_object_set(action, "active", PREFS->stat_showdetail, NULL);
1552
1553 action = gtk_action_group_get_action(actions, "Rate");
1554 g_object_set(action, "active", PREFS->stat_showrate, NULL);
1555
1556 action = gtk_action_group_get_action(actions, "Filter");
1557 g_object_set(action, "is_important", TRUE, NULL);
1558
1559 action = gtk_action_group_get_action(actions, "Refresh");
1560 g_object_set(action, "is_important", TRUE, NULL);
1561
1562
1563 ui = gtk_ui_manager_new ();
1564 gtk_ui_manager_insert_action_group (ui, actions, 0);
1565 gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui));
1566
1567 if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error))
1568 {
1569 g_message ("building UI failed: %s", error->message);
1570 g_error_free (error);
1571 }
1572
1573 data->ui = ui;
1574 data->actions = actions;
1575
1576 //toolbar
1577 data->TB_bar = gtk_ui_manager_get_widget (ui, "/ToolBar");
1578 gtk_box_pack_start (GTK_BOX (vbox), data->TB_bar, FALSE, FALSE, 0);
1579
1580 //infos + balance
1581 hbox = gtk_hbox_new (FALSE, HB_BOX_SPACING);
1582 gtk_container_set_border_width (GTK_CONTAINER(hbox), HB_BOX_SPACING);
1583 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1584
1585 widget = make_label(NULL, 0.5, 0.5);
1586 gimp_label_set_attributes (GTK_LABEL (widget), PANGO_ATTR_SCALE, PANGO_SCALE_SMALL, -1);
1587 data->TX_daterange = widget;
1588 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1589
1590 entry = gtk_label_new(NULL);
1591 data->TX_total[2] = entry;
1592 gtk_box_pack_end (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
1593 label = gtk_label_new(_("Balance:"));
1594 gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1595
1596 entry = gtk_label_new(NULL);
1597 data->TX_total[1] = entry;
1598 gtk_box_pack_end (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
1599 label = gtk_label_new(_("Income:"));
1600 gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1601
1602
1603 entry = gtk_label_new(NULL);
1604 data->TX_total[0] = entry;
1605 gtk_box_pack_end (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
1606 label = gtk_label_new(_("Expense:"));
1607 gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1608
1609
1610 /* report area */
1611 notebook = gtk_notebook_new();
1612 data->GR_result = notebook;
1613 gtk_widget_show(notebook);
1614 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
1615 gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
1616 gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
1617
1618 //page: list
1619 vbox = gtk_vbox_new (FALSE, 0);
1620 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, NULL);
1621
1622 widget = gtk_scrolled_window_new (NULL, NULL);
1623 //gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW (widget), GTK_CORNER_TOP_RIGHT);
1624 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_ETCHED_IN);
1625 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1626 treeview = ui_list_repdist_create();
1627 data->LV_report = treeview;
1628 gtk_container_add (GTK_CONTAINER(widget), treeview);
1629 gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0);
1630
1631 //detail
1632 widget = gtk_scrolled_window_new (NULL, NULL);
1633 data->GR_detail = widget;
1634 //gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW (widget), GTK_CORNER_TOP_RIGHT);
1635 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_ETCHED_IN);
1636 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1637 treeview = create_list_transaction(TRN_LIST_TYPE_DETAIL, PREFS->lst_ope_columns);
1638 data->LV_detail = treeview;
1639 gtk_container_add (GTK_CONTAINER(widget), treeview);
1640
1641 gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0);
1642
1643
1644 //page: 2d bar/pie
1645 widget = gtk_chart_new(CHART_TYPE_COL);
1646 data->RE_chart = widget;
1647 gtk_chart_set_minor_prefs(GTK_CHART(widget), PREFS->euro_value, PREFS->minor_cur.symbol);
1648 //gtk_chart_set_currency(GTK_CHART(widget), GLOBALS->kcur);
1649 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), widget, NULL);
1650
1651 //todo: setup should move this
1652 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_minor), GLOBALS->minor);
1653 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_byamount), PREFS->stat_byamount);
1654
1655 gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_view), 1);
1656
1657 /* attach our minor to treeview */
1658 g_object_set_data(G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_report))), "minor", (gpointer)data->CM_minor);
1659 g_object_set_data(G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_detail))), "minor", (gpointer)data->CM_minor);
1660
1661 /* signal connect */
1662 g_signal_connect (window, "delete-event", G_CALLBACK (ui_repdist_dispose), (gpointer)data);
1663
1664 g_signal_connect (data->CM_minor, "toggled", G_CALLBACK (ui_repdist_toggle_minor), NULL);
1665
1666 data->handler_id[HID_REPDIST_MINDATE] = g_signal_connect (data->PO_mindate, "changed", G_CALLBACK (ui_repdist_date_change), (gpointer)data);
1667 data->handler_id[HID_REPDIST_MAXDATE] = g_signal_connect (data->PO_maxdate, "changed", G_CALLBACK (ui_repdist_date_change), (gpointer)data);
1668
1669 data->handler_id[HID_REPDIST_RANGE] = g_signal_connect (data->CY_range, "changed", G_CALLBACK (ui_repdist_range_change), NULL);
1670
1671 g_signal_connect (data->CY_by, "changed", G_CALLBACK (ui_repdist_compute), (gpointer)data);
1672 data->handler_id[HID_REPDIST_VIEW] = g_signal_connect (data->CY_view, "changed", G_CALLBACK (ui_repdist_compute), (gpointer)data);
1673
1674 g_signal_connect (data->RG_zoomx, "value-changed", G_CALLBACK (ui_repdist_zoomx_callback), NULL);
1675
1676
1677 g_signal_connect (data->CM_byamount, "toggled", G_CALLBACK (ui_repdist_update), NULL);
1678
1679 g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_report)), "changed", G_CALLBACK (ui_repdist_selection), NULL);
1680
1681
1682 //setup, init and show window
1683 ui_repdist_setup(data);
1684
1685 /* toolbar */
1686 if(PREFS->toolbar_style == 0)
1687 gtk_toolbar_unset_style(GTK_TOOLBAR(data->TB_bar));
1688 else
1689 gtk_toolbar_set_style(GTK_TOOLBAR(data->TB_bar), PREFS->toolbar_style-1);
1690
1691
1692 //setup, init and show window
1693 wg = &PREFS->sta_wg;
1694 gtk_window_move(GTK_WINDOW(window), wg->l, wg->t);
1695 gtk_window_resize(GTK_WINDOW(window), wg->w, wg->h);
1696
1697 gtk_widget_show_all (window);
1698
1699
1700
1701 //minor ?
1702 if( PREFS->euro_active )
1703 gtk_widget_show(data->CM_minor);
1704 else
1705 gtk_widget_hide(data->CM_minor);
1706
1707 //gtk_widget_hide(data->GR_detail);
1708
1709
1710
1711 ui_repdist_sensitive(window, NULL);
1712 ui_repdist_update_detail(window, NULL);
1713
1714 DB( g_print("range: %d\n", PREFS->date_range_rep) );
1715
1716 if( PREFS->date_range_rep != 0)
1717 gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_range), PREFS->date_range_rep);
1718 else
1719 ui_repdist_compute(window, NULL);
1720
1721
1722 return window;
1723 }
1724
1725 /*
1726 ** ============================================================================
1727 */
1728
1729 static void ui_list_repdist_rate_cell_data_function (GtkTreeViewColumn *col,
1730 GtkCellRenderer *renderer,
1731 GtkTreeModel *model,
1732 GtkTreeIter *iter,
1733 gpointer user_data)
1734 {
1735 //GtkWidget *widget;
1736
1737 //widget = g_object_get_data(G_OBJECT(model), "minor");
1738
1739 //todo g_assert here and null test
1740
1741 gdouble tmp;
1742 gchar buf[128];
1743
1744 gtk_tree_model_get(model, iter, GPOINTER_TO_INT(user_data), &tmp, -1);
1745
1746 if(tmp != 0.0)
1747 {
1748 g_snprintf(buf, sizeof(buf), "%.2f %%", tmp);
1749 g_object_set(renderer, "text", buf, NULL);
1750 }
1751 else
1752 g_object_set(renderer, "text", "", NULL);
1753
1754 }
1755
1756
1757 static void ui_list_repdist_amount_cell_data_function (GtkTreeViewColumn *col,
1758 GtkCellRenderer *renderer,
1759 GtkTreeModel *model,
1760 GtkTreeIter *iter,
1761 gpointer user_data)
1762 {
1763 gdouble value;
1764 gchar *color;
1765 gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
1766
1767 gtk_tree_model_get(model, iter, GPOINTER_TO_INT(user_data), &value, -1);
1768
1769 if( value )
1770 {
1771 mystrfmon(buf, G_ASCII_DTOSTR_BUF_SIZE-1, value, GLOBALS->minor);
1772 //hb_strfmon(buf, G_ASCII_DTOSTR_BUF_SIZE-1, value, GLOBALS->kcur);
1773
1774 color = get_normal_color_amount(value);
1775
1776 g_object_set(renderer,
1777 "foreground", color,
1778 "text", buf,
1779 NULL); }
1780 else
1781 {
1782 g_object_set(renderer, "text", "", NULL);
1783 }
1784 }
1785
1786
1787 static GtkTreeViewColumn *ui_list_repdist_amount_column(gchar *name, gint id)
1788 {
1789 GtkTreeViewColumn *column;
1790 GtkCellRenderer *renderer;
1791
1792 column = gtk_tree_view_column_new();
1793 gtk_tree_view_column_set_title(column, name);
1794 renderer = gtk_cell_renderer_text_new ();
1795 g_object_set(renderer, "xalign", 1.0, NULL);
1796 gtk_tree_view_column_pack_start(column, renderer, TRUE);
1797 gtk_tree_view_column_set_cell_data_func(column, renderer, ui_list_repdist_amount_cell_data_function, GINT_TO_POINTER(id), NULL);
1798 gtk_tree_view_column_set_alignment (column, 0.5);
1799 //gtk_tree_view_column_set_sort_column_id (column, id);
1800 return column;
1801 }
1802
1803 static GtkTreeViewColumn *ui_list_repdist_rate_column(gint id)
1804 {
1805 GtkTreeViewColumn *column;
1806 GtkCellRenderer *renderer;
1807
1808 column = gtk_tree_view_column_new();
1809 gtk_tree_view_column_set_title(column, "%");
1810 renderer = gtk_cell_renderer_text_new ();
1811 g_object_set(renderer, "xalign", 1.0, "yalign", 1.0, "scale", 0.8, "scale-set", TRUE, NULL);
1812
1813 gtk_tree_view_column_pack_start(column, renderer, TRUE);
1814 //gtk_tree_view_column_add_attribute(column, renderer, "text", id);
1815 gtk_tree_view_column_set_cell_data_func(column, renderer, ui_list_repdist_rate_cell_data_function, GINT_TO_POINTER(id), NULL);
1816 gtk_tree_view_column_set_alignment (column, 0.5);
1817 //gtk_tree_view_column_set_sort_column_id (column, id);
1818
1819 //gtk_tree_view_column_set_visible(column, FALSE);
1820
1821 return column;
1822 }
1823
1824 /*
1825 ** create our statistic list
1826 */
1827 static GtkWidget *ui_list_repdist_create(void)
1828 {
1829 GtkListStore *store;
1830 GtkWidget *view;
1831 GtkCellRenderer *renderer;
1832 GtkTreeViewColumn *column;
1833
1834 /* create list store */
1835 store = gtk_list_store_new(
1836 NUM_LST_REPDIST,
1837 G_TYPE_INT,
1838 G_TYPE_INT,
1839 G_TYPE_STRING,
1840 G_TYPE_DOUBLE,
1841 G_TYPE_DOUBLE,
1842 G_TYPE_DOUBLE,
1843 G_TYPE_DOUBLE,
1844 G_TYPE_DOUBLE,
1845 G_TYPE_DOUBLE
1846 );
1847
1848 //treeview
1849 view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
1850 g_object_unref(store);
1851
1852 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), PREFS->rules_hint);
1853
1854 /* column: Name */
1855 column = gtk_tree_view_column_new();
1856 gtk_tree_view_column_set_title(column, _("Result"));
1857 renderer = gtk_cell_renderer_text_new ();
1858 gtk_tree_view_column_pack_start(column, renderer, TRUE);
1859 //gtk_tree_view_column_set_cell_data_func(column, renderer, ope_result_cell_data_function, NULL, NULL);
1860 gtk_tree_view_column_add_attribute(column, renderer, "text", LST_REPDIST_NAME);
1861 //gtk_tree_view_column_set_sort_column_id (column, LST_REPDIST_NAME);
1862 gtk_tree_view_column_set_resizable(column, TRUE);
1863 gtk_tree_view_column_set_alignment (column, 0.5);
1864 gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1865
1866 /* column: Expense */
1867 column = ui_list_repdist_amount_column(_("Expense"), LST_REPDIST_EXPENSE);
1868 gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1869 column = ui_list_repdist_rate_column(LST_REPDIST_EXPRATE);
1870 gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1871
1872 /* column: Income */
1873 column = ui_list_repdist_amount_column(_("Income"), LST_REPDIST_INCOME);
1874 gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1875 column = ui_list_repdist_rate_column(LST_REPDIST_INCRATE);
1876 gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1877
1878 /* column: Balance */
1879 column = ui_list_repdist_amount_column(_("Balance"), LST_REPDIST_BALANCE);
1880 gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1881 column = ui_list_repdist_rate_column(LST_REPDIST_BALRATE);
1882 gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1883
1884 /* column last: empty */
1885 column = gtk_tree_view_column_new();
1886 gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1887
1888 /* sort */
1889 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_REPDIST_POS , ui_list_repdist_compare_func, GINT_TO_POINTER(LST_REPDIST_POS), NULL);
1890 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_REPDIST_EXPENSE, ui_list_repdist_compare_func, GINT_TO_POINTER(LST_REPDIST_EXPENSE), NULL);
1891 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_REPDIST_INCOME , ui_list_repdist_compare_func, GINT_TO_POINTER(LST_REPDIST_INCOME), NULL);
1892 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_REPDIST_BALANCE, ui_list_repdist_compare_func, GINT_TO_POINTER(LST_REPDIST_BALANCE), NULL);
1893
1894
1895 return(view);
1896 }
1897
1898 static gint ui_list_repdist_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
1899 {
1900 gint sortcol = GPOINTER_TO_INT(userdata);
1901 gint retval = 0;
1902 gint pos1, pos2;
1903 gdouble val1, val2;
1904
1905 gtk_tree_model_get(model, a,
1906 LST_REPDIST_POS, &pos1,
1907 sortcol, &val1,
1908 -1);
1909 gtk_tree_model_get(model, b,
1910 LST_REPDIST_POS, &pos2,
1911 sortcol, &val2,
1912 -1);
1913
1914 switch(sortcol)
1915 {
1916 case LST_REPDIST_POS:
1917 retval = pos2 - pos1;
1918 break;
1919 default:
1920 retval = (ABS(val1) - ABS(val2)) > 0 ? 1 : -1;
1921 break;
1922 }
1923
1924 //DB( g_print(" sort %d=%d or %.2f=%.2f :: %d\n", pos1,pos2, val1, val2, ret) );
1925
1926 return retval;
1927 }
1928
fork of homebank with support for plugins
This page took 0.121141 seconds and 4 git commands to generate.