Dogcows Code - chaz/homebank/blob - src/rep-time.c

   1 /*  HomeBank -- Free, easy, personal accounting for everyone.
   2  *  Copyright (C) 1995-2019 Maxime DOYEN
   3  *
   4  *  This file is part of HomeBank.
   5  *
   6  *  HomeBank is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  HomeBank is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20
  21 #include "homebank.h"
  22
  23 #include "rep-time.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 #include "ui-transaction.h"
  35 #include "ui-tag.h"
  36
  37
  38 /****************************************************************************/
  39 /* Debug macros                                                             */
  40 /****************************************************************************/
  41 #define MYDEBUG 0
  42
  43 #if MYDEBUG
  44 #define DB(x) (x);
  45 #else
  46 #define DB(x);
  47 #endif
  48
  49 /* our global datas */
  50 extern struct HomeBank *GLOBALS;
  51 extern struct Preferences *PREFS;
  52
  53
  54 /* prototypes */
  55 static void ui_reptime_action_viewlist(GtkAction *action, gpointer user_data);
  56 static void ui_reptime_action_viewcolumn(GtkAction *action, gpointer user_data);
  57 static void ui_reptime_action_viewline(GtkAction *action, gpointer user_data);
  58 static void ui_reptime_action_detail(GtkAction *action, gpointer user_data);
  59 //static void ui_reptime_action_filter(GtkAction *action, gpointer user_data);
  60 static void ui_reptime_action_refresh(GtkAction *action, gpointer user_data);
  61
  62 static void ui_reptime_list_set_cur(GtkTreeView *treeview, guint32 kcur);
  63
  64
  65 static GtkRadioActionEntry radio_entries[] = {
  66   { "List"    , ICONNAME_HB_VIEW_LIST  , N_("List")   , NULL,    N_("View results as list")  , 0 },
  67   { "Line"    , ICONNAME_HB_VIEW_LINE  , N_("Line")   , NULL,    N_("View results as lines") , 1 },
  68   { "Column"  , ICONNAME_HB_VIEW_COLUMN, N_("Column") , NULL,    N_("View results as column"), 2 },
  69 };
  70 static guint n_radio_entries = G_N_ELEMENTS (radio_entries);
  71
  72 static GtkActionEntry entries[] = {
  73 //  { "Filter"  , ICONNAME_HB_FILTER    , N_("Filter") , NULL,   N_("Edit the filter"), G_CALLBACK (ui_reptime_action_filter) },
  74   { "Refresh" , ICONNAME_HB_REFRESH   , N_("Refresh"), NULL,   N_("Refresh results"), G_CALLBACK (ui_reptime_action_refresh) },
  75
  76 //  { "Export" , ICONNAME_HB_FILE_EXPORT, N_("Export")  , NULL,   N_("Export as CSV"), G_CALLBACK (ui_reptime_action_export) },
  77 };
  78 static guint n_entries = G_N_ELEMENTS (entries);
  79
  80 static GtkToggleActionEntry toggle_entries[] = {
  81   { "Detail", ICONNAME_HB_OPE_SHOW,                    /* name, icon-name */
  82      N_("Detail"), NULL,                    /* label, accelerator */
  83     N_("Toggle detail"),                                    /* tooltip */
  84     G_CALLBACK (ui_reptime_action_detail),
  85     FALSE },                                    /* is_active */
  86
  87 };
  88 static guint n_toggle_entries = G_N_ELEMENTS (toggle_entries);
  89
  90
  91 static const gchar *ui_info =
  92 "<ui>"
  93 "  <toolbar name='ToolBar'>"
  94 "    <toolitem action='List'/>"
  95 "    <toolitem action='Line'/>"
  96 "    <toolitem action='Column'/>"
  97 "      <separator/>"
  98 "    <toolitem action='Detail'/>"
  99 "      <separator/>"
 100 //"    <toolitem action='Filter'/>"
 101 "    <toolitem action='Refresh'/>"
 102 "      <separator/>"
 103 //"    <toolitem action='Export'/>"
 104 //              replaced by a menubutton
 105 "  </toolbar>"
 106 "</ui>";
 107
 108
 109 static void ui_reptime_date_change(GtkWidget *widget, gpointer user_data);
 110 static void ui_reptime_range_change(GtkWidget *widget, gpointer user_data);
 111 static void ui_reptime_detail(GtkWidget *widget, gpointer user_data);
 112 static void ui_reptime_update(GtkWidget *widget, gpointer user_data);
 113 static void ui_reptime_compute(GtkWidget *widget, gpointer user_data);
 114 static void ui_reptime_sensitive(GtkWidget *widget, gpointer user_data);
 115 static void ui_reptime_toggle_detail(GtkWidget *widget, gpointer user_data);
 116 static void ui_reptime_toggle_minor(GtkWidget *widget, gpointer user_data);
 117 static void ui_reptime_update_daterange(GtkWidget *widget, gpointer user_data);
 118 static GtkWidget *ui_list_reptime_create(void);
 119
 120 static gint ui_list_reptime_compare_func (GtkTreeModel *model, GtkTreeIter  *a, GtkTreeIter  *b, gpointer      userdata);
 121 static GString *ui_list_reptime_to_string(GtkTreeView *treeview, gboolean clipboard);
 122
 123
 124 HbKvData CYA_REPORT_SRC_TREND[] = {
 125         { REPORT_SRC_ACCOUNT,   N_("Account") },
 126         { REPORT_SRC_CATEGORY,  N_("Category") },
 127         { REPORT_SRC_PAYEE,             N_("Payee") },
 128         { REPORT_SRC_TAG,               N_("Tag") },
 129         { 0, NULL }
 130 };
 131
 132
 133 HbKvData CYA_REPORT_INTVL[] = {
 134         { REPORT_INTVL_DAY,             N_("Day") },
 135         { REPORT_INTVL_WEEK,    N_("Week") },
 136         { REPORT_INTVL_MONTH,   N_("Month") },
 137         { REPORT_INTVL_QUARTER, N_("Quarter") },
 138         { REPORT_INTVL_HALFYEAR,N_("Half Year") },
 139         { REPORT_INTVL_YEAR,    N_("Year") },
 140         { 0, NULL }
 141 };
 142
 143
 144 extern gchar *RA_REPORT_TIME_MODE[];
 145 extern gchar *CYA_ABMONTHS[];
 146
 147
 148
 149 /* action functions -------------------- */
 150
 151
 152 static void ui_reptime_action_viewlist(GtkAction *action, gpointer user_data)
 153 {
 154 struct ui_reptime_data *data = user_data;
 155
 156         data->charttype = CHART_TYPE_NONE;
 157         gtk_notebook_set_current_page(GTK_NOTEBOOK(data->GR_result), 0);
 158         ui_reptime_sensitive(data->window, NULL);
 159 }
 160
 161 static void ui_reptime_action_viewline(GtkAction *action, gpointer user_data)
 162 {
 163 struct ui_reptime_data *data = user_data;
 164
 165         data->charttype = CHART_TYPE_LINE;
 166         gtk_notebook_set_current_page(GTK_NOTEBOOK(data->GR_result), 1);
 167         ui_reptime_sensitive(data->window, NULL);
 168         ui_reptime_update(data->window, NULL);
 169 }
 170
 171
 172 static void ui_reptime_action_viewcolumn(GtkAction *action, gpointer user_data)
 173 {
 174 struct ui_reptime_data *data = user_data;
 175
 176         data->charttype = CHART_TYPE_COL;
 177         gtk_notebook_set_current_page(GTK_NOTEBOOK(data->GR_result), 1);
 178         ui_reptime_sensitive(data->window, NULL);
 179         ui_reptime_update(data->window, NULL);
 180
 181 }
 182
 183
 184 static void ui_reptime_action_mode (GtkRadioAction *action, GtkRadioAction *current, gpointer user_data)
 185 {
 186 gint value;
 187
 188         value = gtk_radio_action_get_current_value(GTK_RADIO_ACTION(action));
 189         switch( value )
 190         {
 191                 case 0:
 192                         ui_reptime_action_viewlist(GTK_ACTION(action), user_data);
 193                         break;
 194                 case 1:
 195                         ui_reptime_action_viewline(GTK_ACTION(action), user_data);
 196                         break;
 197                 case 2:
 198                         ui_reptime_action_viewcolumn (GTK_ACTION(action), user_data);
 199                         break;
 200         }
 201 }
 202
 203
 204 static void ui_reptime_action_detail(GtkAction *action, gpointer user_data)
 205 {
 206 struct ui_reptime_data *data = user_data;
 207
 208         ui_reptime_toggle_detail(data->window, NULL);
 209 }
 210
 211 /*
 212 static void ui_reptime_action_filter(GtkAction *action, gpointer user_data)
 213 {
 214 struct ui_reptime_data *data = user_data;
 215
 216         //debug
 217         //create_deffilter_window(data->filter, TRUE);
 218
 219         if(create_deffilter_window(data->filter, TRUE) != GTK_RESPONSE_REJECT)
 220                 ui_reptime_compute(data->window, NULL);
 221 }
 222 */
 223
 224 static void ui_reptime_action_refresh(GtkAction *action, gpointer user_data)
 225 {
 226 struct ui_reptime_data *data = user_data;
 227
 228         ui_reptime_compute(data->window, NULL);
 229 }
 230
 231 /*static void ui_reptime_action_export(GtkAction *action, gpointer user_data)
 232 {
 233 struct ui_reptime_data *data = user_data;
 234
 235         ui_reptime_export_csv(data->window, NULL);
 236 }*/
 237
 238
 239
 240 /* ======================== */
 241
 242
 243
 244 /*
 245 ** ============================================================================
 246 */
 247
 248 /*
 249 ** return the year list position correponding to the passed date
 250 */
 251
 252 static void ui_reptime_date_change(GtkWidget *widget, gpointer user_data)
 253 {
 254 struct ui_reptime_data *data;
 255
 256         DB( g_print("\n[reptime] date change\n") );
 257
 258         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 259
 260         data->filter->mindate = gtk_date_entry_get_date(GTK_DATE_ENTRY(data->PO_mindate));
 261         data->filter->maxdate = gtk_date_entry_get_date(GTK_DATE_ENTRY(data->PO_maxdate));
 262
 263         // set min/max date for both widget
 264         gtk_date_entry_set_maxdate(GTK_DATE_ENTRY(data->PO_mindate), data->filter->maxdate);
 265         gtk_date_entry_set_mindate(GTK_DATE_ENTRY(data->PO_maxdate), data->filter->mindate);
 266
 267         g_signal_handler_block(data->CY_range, data->handler_id[HID_REPTIME_RANGE]);
 268         gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_range), FLT_RANGE_OTHER);
 269         g_signal_handler_unblock(data->CY_range, data->handler_id[HID_REPTIME_RANGE]);
 270
 271         ui_reptime_compute(widget, NULL);
 272         ui_reptime_update_daterange(widget, NULL);
 273
 274 }
 275
 276
 277 static void ui_reptime_update_quickdate(GtkWidget *widget, gpointer user_data)
 278 {
 279 struct ui_reptime_data *data;
 280
 281         DB( g_print("\n[reptime] update quickdate\n") );
 282
 283         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 284
 285         g_signal_handler_block(data->PO_mindate, data->handler_id[HID_REPTIME_MINDATE]);
 286         g_signal_handler_block(data->PO_maxdate, data->handler_id[HID_REPTIME_MAXDATE]);
 287
 288         gtk_date_entry_set_date(GTK_DATE_ENTRY(data->PO_mindate), data->filter->mindate);
 289         gtk_date_entry_set_date(GTK_DATE_ENTRY(data->PO_maxdate), data->filter->maxdate);
 290
 291         g_signal_handler_unblock(data->PO_mindate, data->handler_id[HID_REPTIME_MINDATE]);
 292         g_signal_handler_unblock(data->PO_maxdate, data->handler_id[HID_REPTIME_MAXDATE]);
 293
 294 }
 295
 296
 297 static void ui_reptime_range_change(GtkWidget *widget, gpointer user_data)
 298 {
 299 struct ui_reptime_data *data;
 300 gint range;
 301
 302         DB( g_print("\n[reptime] range change\n") );
 303
 304         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 305
 306         range = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_range));
 307
 308         if(range != FLT_RANGE_OTHER)
 309         {
 310                 filter_preset_daterange_set(data->filter, range, data->accnum);
 311
 312                 ui_reptime_update_quickdate(widget, NULL);
 313
 314                 ui_reptime_compute(widget, NULL);
 315                 ui_reptime_update_daterange(widget, NULL);
 316         }
 317
 318 }
 319
 320 static void ui_reptime_update_daterange(GtkWidget *widget, gpointer user_data)
 321 {
 322 struct ui_reptime_data *data;
 323 gchar *daterange;
 324
 325         DB( g_print("\n[reptime] update daterange\n") );
 326
 327         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 328
 329         daterange = filter_daterange_text_get(data->filter);
 330         gtk_label_set_markup(GTK_LABEL(data->TX_daterange), daterange);
 331         g_free(daterange);
 332 }
 333
 334
 335
 336
 337 static void ui_reptime_update(GtkWidget *widget, gpointer user_data)
 338 {
 339 struct ui_reptime_data *data;
 340 GtkTreeModel *model;
 341 gint page;
 342 gint tmpsrc;
 343 gchar *title;
 344
 345         DB( g_print("\n[reptime] update\n") );
 346
 347         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 348
 349
 350         model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_report));
 351         //byamount = 0;
 352         tmpsrc  = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_src));
 353         //tmpintvl = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_intvl));
 354
 355         // ensure not exp & inc for piechart
 356         page = gtk_notebook_get_current_page(GTK_NOTEBOOK(data->GR_result));
 357
 358         DB( g_print(" page %d\n\n", page) );
 359         //DB( g_print(" tmpintvl %d\n\n", tmpintvl) );
 360
 361         //column = LST_REPTIME_POS;
 362         //DB( g_print(" sort on column %d\n\n", column) );
 363         //gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), column, GTK_SORT_DESCENDING);
 364
 365         gtk_chart_show_legend(GTK_CHART(data->RE_line), FALSE, FALSE);
 366         gtk_chart_show_xval(GTK_CHART(data->RE_line), TRUE);
 367
 368         //visible = (tmpmode == REPORT_RESULT_TOTAL) ? TRUE : FALSE;
 369         //gtk_chart_show_average(GTK_CHART(data->RE_line), data->average, visible);
 370
 371         //TRANSLATORS: example 'Category Over Time'
 372         title = g_strdup_printf(_("%s Over Time"), hbtk_get_label(CYA_REPORT_SRC_TREND, tmpsrc) );
 373         gtk_chart_set_datas(GTK_CHART(data->RE_line), model, LST_REPTIME_AMOUNT, title, NULL);
 374         g_free(title);
 375
 376         if(page == 1)
 377         {
 378                 DB(     g_print(" change chart type to %d\n", data->charttype) );
 379                 gtk_chart_set_type (GTK_CHART(data->RE_line), data->charttype);
 380                 gtk_chart_set_showmono(GTK_CHART(data->RE_line), TRUE);
 381         }
 382
 383 }
 384
 385
 386 static void ui_reptime_export_result_clipboard(GtkWidget *widget, gpointer user_data)
 387 {
 388 struct ui_reptime_data *data;
 389 GtkClipboard *clipboard;
 390 GString *node;
 391
 392         DB( g_print("\n[reptime] export result clipboard\n") );
 393
 394         data = user_data;
 395         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 396
 397         node = ui_list_reptime_to_string(GTK_TREE_VIEW(data->LV_report), TRUE);
 398
 399         clipboard = gtk_clipboard_get_default(gdk_display_get_default());
 400         gtk_clipboard_set_text(clipboard, node->str, node->len);
 401
 402         g_string_free(node, TRUE);
 403 }
 404
 405
 406 static void ui_reptime_export_result_csv(GtkWidget *widget, gpointer user_data)
 407 {
 408 struct ui_reptime_data *data;
 409 gchar *filename = NULL;
 410 GString *node;
 411 GIOChannel *io;
 412 gchar *name;
 413 gint tmpsrc;
 414
 415         DB( g_print("\n[reptime] export result csv\n") );
 416
 417         data = user_data;
 418         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 419
 420         tmpsrc  = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_src));
 421         name = g_strdup_printf("hb-reptime_%s.csv", hbtk_get_label(CYA_REPORT_SRC_TREND, tmpsrc) );
 422
 423         if( ui_file_chooser_csv(GTK_WINDOW(data->window), GTK_FILE_CHOOSER_ACTION_SAVE, &filename, name) == TRUE )
 424         {
 425                 DB( g_print(" + filename is %s\n", filename) );
 426                 io = g_io_channel_new_file(filename, "w", NULL);
 427                 if(io != NULL)
 428                 {
 429                         node = ui_list_reptime_to_string(GTK_TREE_VIEW(data->LV_report), FALSE);
 430                         g_io_channel_write_chars(io, node->str, -1, NULL, NULL);
 431                         g_io_channel_unref (io);
 432                         g_string_free(node, TRUE);
 433                 }
 434                 g_free( filename );
 435         }
 436         g_free(name);
 437 }
 438
 439
 440 static void ui_reptime_export_detail_clipboard(GtkWidget *widget, gpointer user_data)
 441 {
 442 struct ui_reptime_data *data;
 443 GtkClipboard *clipboard;
 444 GString *node;
 445
 446         DB( g_print("\n[reptime] export detail clipboard\n") );
 447
 448         data = user_data;
 449         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 450
 451         node = list_txn_to_string(GTK_TREE_VIEW(data->LV_detail), TRUE);
 452
 453         clipboard = gtk_clipboard_get_default(gdk_display_get_default());
 454         gtk_clipboard_set_text(clipboard, node->str, node->len);
 455
 456         g_string_free(node, TRUE);
 457 }
 458
 459
 460 static void ui_reptime_export_detail_csv(GtkWidget *widget, gpointer user_data)
 461 {
 462 struct ui_reptime_data *data;
 463 gchar *filename = NULL;
 464 GString *node;
 465 GIOChannel *io;
 466 gchar *name;
 467 gint tmpsrc;
 468
 469         DB( g_print("\n[reptime] export detail csv\n") );
 470
 471         data = user_data;
 472         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 473
 474         tmpsrc  = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_src));
 475         name = g_strdup_printf("hb-reptime-detail_%s.csv", hbtk_get_label(CYA_REPORT_SRC_TREND, tmpsrc) );
 476
 477         if( ui_file_chooser_csv(GTK_WINDOW(data->window), GTK_FILE_CHOOSER_ACTION_SAVE, &filename, name) == TRUE )
 478         {
 479                 DB( g_print(" + filename is %s\n", filename) );
 480
 481                 io = g_io_channel_new_file(filename, "w", NULL);
 482                 if(io != NULL)
 483                 {
 484                         node = list_txn_to_string(GTK_TREE_VIEW(data->LV_detail), FALSE);
 485                         g_io_channel_write_chars(io, node->str, -1, NULL, NULL);
 486
 487                         g_io_channel_unref (io);
 488                         g_string_free(node, TRUE);
 489                 }
 490
 491                 g_free( filename );
 492         }
 493
 494         g_free(name);
 495 }
 496
 497
 498 static void ui_reptime_update_for(GtkWidget *widget, gpointer user_data)
 499 {
 500 struct ui_reptime_data *data;
 501 gint tmpsrc;
 502 gboolean visible;
 503
 504         DB( g_print("\n[reptime] update for\n") );
 505
 506         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 507
 508         tmpsrc  = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_src));
 509
 510         visible = tmpsrc == REPORT_SRC_ACCOUNT ? TRUE : FALSE;
 511         hb_widget_visible(data->LB_acc, visible);
 512         hb_widget_visible(data->PO_acc, visible);
 513
 514         visible = tmpsrc == REPORT_SRC_CATEGORY ? TRUE : FALSE;
 515         hb_widget_visible(data->LB_cat, visible);
 516         hb_widget_visible(data->PO_cat, visible);
 517
 518         visible = tmpsrc == REPORT_SRC_PAYEE ? TRUE : FALSE;
 519         hb_widget_visible(data->LB_pay, visible);
 520         hb_widget_visible(data->PO_pay, visible);
 521
 522         visible = tmpsrc == REPORT_SRC_TAG ? TRUE : FALSE;
 523         hb_widget_visible(data->LB_tag, visible);
 524         hb_widget_visible(data->PO_tag, visible);
 525
 526 }
 527
 528
 529
 530 static void ui_reptime_for(GtkWidget *widget, gpointer user_data)
 531 {
 532 struct ui_reptime_data *data;
 533
 534         DB( g_print("\n[reptime] for\n") );
 535
 536         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 537
 538         ui_reptime_update_for(widget, data);
 539
 540         ui_reptime_compute(widget, data);
 541 }
 542
 543
 544 //TODO: this is temporary, as at end we will enable filter
 545 static void ui_reptime_compute_set_filter(Filter *flt, gint tmpsrc, guint32 selkey)
 546 {
 547         //inactive all filters
 548         flt->option[FILTER_CATEGORY] = 0;
 549         flt->option[FILTER_PAYEE] = 0;
 550         flt->option[FILTER_ACCOUNT] = 0;
 551         flt->option[FILTER_TEXT] = 0;
 552
 553         switch(tmpsrc)
 554         {
 555                 case REPORT_SRC_ACCOUNT:
 556                         flt->option[FILTER_ACCOUNT] = 1;
 557                         filter_status_acc_clear_except(flt, selkey);
 558                         break;
 559                 case REPORT_SRC_CATEGORY:
 560                         flt->option[FILTER_CATEGORY] = 1;
 561                         filter_status_cat_clear_except(flt, selkey);
 562                         break;
 563                 case REPORT_SRC_PAYEE:
 564                         flt->option[FILTER_PAYEE] = 1;
 565                         filter_status_pay_clear_except(flt, selkey);
 566                         break;
 567                 case REPORT_SRC_TAG:
 568                         flt->option[FILTER_TEXT] = 1;
 569                         filter_set_tag_by_id(flt, selkey);
 570                         break;
 571         }
 572
 573
 574 }
 575
 576
 577 static void ui_reptime_detail(GtkWidget *widget, gpointer user_data)
 578 {
 579 struct ui_reptime_data *data;
 580 guint active = GPOINTER_TO_INT(user_data);
 581 guint tmpintvl;
 582 guint32 from;
 583 GList *list;
 584 GtkTreeModel *model;
 585 GtkTreeIter  iter;
 586
 587         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 588
 589         DB( g_print("\n[reptime] detail\n") );
 590
 591         //tmpsrc  = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_src));
 592         tmpintvl = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_intvl));
 593
 594         //ui_reptime_compute_set_filter was already called here
 595
 596         //get our min max date
 597         from = data->filter->mindate;
 598         //to   = data->filter->maxdate;
 599
 600         /* clear and detach our model */
 601         model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_detail));
 602         gtk_list_store_clear (GTK_LIST_STORE(model));
 603
 604         if(data->detail)
 605         {
 606                 g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
 607                 gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_detail), NULL); /* Detach model from view */
 608
 609                 /* fill in the model */
 610                 list = g_queue_peek_head_link(data->txn_queue);
 611                 while (list != NULL)
 612                 {
 613                 Transaction *ope = list->data;
 614                 guint pos;
 615
 616                         if(filter_txn_match(data->filter, ope) == 1)
 617                         {
 618                                 pos = report_interval_get_pos(tmpintvl, from, ope);
 619                                 if( pos == active )
 620                                 {
 621                                         gtk_list_store_insert_with_values (GTK_LIST_STORE(model), &iter, -1,
 622                                                 LST_DSPOPE_DATAS, ope,
 623                                                 -1);
 624                                 }
 625                         }
 626
 627                         list = g_list_next(list);
 628                 }
 629
 630                 /* Re-attach model to view */
 631                 gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_detail), model);
 632                 g_object_unref(model);
 633
 634                 gtk_tree_view_columns_autosize( GTK_TREE_VIEW(data->LV_detail) );
 635         }
 636
 637 }
 638
 639
 640 static void ui_reptime_compute(GtkWidget *widget, gpointer user_data)
 641 {
 642 struct ui_reptime_data *data;
 643 gint tmpsrc, tmpintvl, range, showempty;
 644 guint32 from, to;
 645 gboolean cumul;
 646 gboolean showall;
 647
 648 gdouble cumulation, average;
 649
 650 GtkTreeModel *model;
 651 GtkTreeIter  iter;
 652 GList *list;
 653 gint id;
 654 guint n_result, i;
 655 gdouble *tmp_amount;
 656 guint32 selkey;
 657
 658         DB( g_print("\n[reptime] compute\n") );
 659
 660         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 661
 662         tmpsrc    = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_src));
 663         tmpintvl  = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_intvl));
 664         cumul     = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_cumul));
 665         showall   = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_all));
 666         range     = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_range));
 667         showempty = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_showempty));
 668
 669         selkey = 0;
 670
 671         data->accnum = 0;
 672         switch(tmpsrc)
 673         {
 674                 case REPORT_SRC_ACCOUNT:
 675                         selkey = ui_acc_comboboxentry_get_key(GTK_COMBO_BOX(data->PO_acc));
 676                         if(showall == FALSE)
 677                                 data->accnum = selkey;
 678                         break;
 679                 case REPORT_SRC_CATEGORY:
 680                         selkey = ui_cat_comboboxentry_get_key(GTK_COMBO_BOX(data->PO_cat));
 681                         break;
 682                 case REPORT_SRC_PAYEE:
 683                         selkey = ui_pay_comboboxentry_get_key(GTK_COMBO_BOX(data->PO_pay));
 684                         break;
 685                 case REPORT_SRC_TAG:
 686                         selkey = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->PO_tag));
 687                         break;
 688         }
 689
 690         if( showall == TRUE )
 691         {
 692                 data->filter->option[FILTER_CATEGORY] = 0;
 693                 data->filter->option[FILTER_PAYEE] = 0;
 694                 data->filter->option[FILTER_ACCOUNT] = 0;
 695                 data->filter->option[FILTER_TEXT] = 0;
 696         }
 697         else
 698                 ui_reptime_compute_set_filter(data->filter, tmpsrc, selkey);
 699
 700
 701         DB( g_print(" source=%d-%s, intvl=%d-%s:: key=%d\n", tmpsrc, hbtk_get_label(CYA_REPORT_SRC_TREND, tmpsrc), tmpintvl, hbtk_get_label(CYA_REPORT_INTVL, tmpintvl), selkey) );
 702
 703         //to remove > 5.0.2
 704         //#1715532 5.0.5: no... but only showall
 705         if( (showall == TRUE) && (range == FLT_RANGE_ALLDATE) )
 706         {
 707                 filter_preset_daterange_set(data->filter, data->filter->range, data->accnum);
 708                 ui_reptime_update_quickdate(widget, NULL);
 709         }
 710
 711         //get our min max date
 712         from = data->filter->mindate;
 713         to   = data->filter->maxdate;
 714         if(to < from) return;
 715
 716         g_queue_free (data->txn_queue);
 717         data->txn_queue = hbfile_transaction_get_partial(data->filter->mindate, data->filter->maxdate);
 718
 719         n_result = report_interval_count(tmpintvl, from, to);
 720
 721         DB( g_print(" %s :: n_result=%d\n", hbtk_get_label(CYA_REPORT_SRC_TREND, tmpsrc), n_result) );
 722
 723         /* allocate some memory */
 724         tmp_amount = g_malloc0((n_result+2) * sizeof(gdouble));
 725
 726         if(tmp_amount)
 727         {
 728                 list = g_queue_peek_head_link(data->txn_queue);
 729                 while (list != NULL)
 730                 {
 731                 Transaction *ope = list->data;
 732
 733                         //DB( g_print("\n** testing '%s', cat=%d==> %d\n", ope->memo, ope->kcat, filter_txn_match(data->filter, ope)) );
 734
 735                         if( (filter_txn_match(data->filter, ope) == 1) )
 736                         {
 737                         guint pos;
 738                         gdouble trn_amount;
 739
 740                                 trn_amount = report_txn_amount_get(data->filter, ope);
 741
 742                                 if( tmpsrc == REPORT_SRC_ACCOUNT && showall == TRUE )
 743                                         trn_amount = hb_amount_base(trn_amount, ope->kcur);
 744
 745                                 pos = report_interval_get_pos(tmpintvl, from, ope);
 746                                 if( pos <= n_result )
 747                                 {
 748                                         DB( g_print("** pos=%d : add of %.2f\n", pos, trn_amount) );
 749                                         tmp_amount[pos] += trn_amount;
 750                                 }
 751                                 else
 752                                 {
 753                                         DB( g_print("** pos=%d : invalid offset\n", pos) );
 754                                 }
 755                         }
 756                         list = g_list_next(list);
 757                 }
 758
 759                 /* clear and detach our model */
 760                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_report));
 761                 gtk_list_store_clear (GTK_LIST_STORE(model));
 762                 g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
 763                 gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_report), NULL); /* Detach model from view */
 764
 765                 cumulation = 0.0;
 766
 767                 /* insert into the treeview */
 768                 for(i=0, id=0; i<n_result; i++)
 769                 {
 770                 gchar intvlname[64];
 771                 gdouble value;
 772
 773                         if( !showempty && tmp_amount[i] == 0 )
 774                                 continue;
 775
 776                         report_interval_snprint_name(intvlname, sizeof(intvlname)-1, tmpintvl, from, i);
 777
 778                         DB( g_print("try to insert item %d\n", i) );
 779
 780                         cumulation += tmp_amount[i];
 781                         value = (cumul == TRUE) ? cumulation : tmp_amount[i];
 782
 783                         DB( g_print(" inserting %2d, '%s', %9.2f\n", i, intvlname, value) );
 784
 785                 gtk_list_store_insert_with_values (GTK_LIST_STORE(model), &iter, -1,
 786                                 LST_REPTIME_POS, id++,
 787                                 LST_REPTIME_KEY, i,
 788                                 LST_REPTIME_TITLE, intvlname,
 789                                 LST_REPTIME_AMOUNT, value,
 790                                 -1);
 791
 792                 }
 793
 794                 // set chart and listview currency
 795                 guint32 kcur = GLOBALS->kcur;
 796                 if( (showall == FALSE) && (tmpsrc == REPORT_SRC_ACCOUNT) )
 797                 {
 798                 Account *acc = da_acc_get(selkey);
 799                         if( acc != NULL )
 800                                 kcur = acc->kcur;
 801
 802                         gtk_chart_set_overdrawn(GTK_CHART(data->RE_line), acc->minimum);
 803                 }
 804
 805                 ui_reptime_list_set_cur(GTK_TREE_VIEW(data->LV_report), kcur);
 806                 gtk_chart_set_currency(GTK_CHART(data->RE_line), kcur);
 807
 808
 809                 /* update column 0 title */
 810                 GtkTreeViewColumn *column = gtk_tree_view_get_column( GTK_TREE_VIEW(data->LV_report), 0);
 811                 if(column)
 812                         gtk_tree_view_column_set_title(column, hbtk_get_label(CYA_REPORT_INTVL, tmpintvl) );
 813
 814                 gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_report));
 815
 816                 /* Re-attach model to view */
 817                 gtk_tree_view_set_model(GTK_TREE_VIEW(data->LV_report), model);
 818                 g_object_unref(model);
 819
 820                 //update average
 821                 gtk_label_set_text(GTK_LABEL(data->TX_info), "");
 822
 823                 if( cumul == TRUE )
 824                 {
 825                 gchar *info;
 826                 gchar   buf[128];
 827
 828                         average = cumulation / n_result;
 829                         data->average = average;
 830
 831                         hb_strfmon(buf, 127, average, kcur, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_minor)) );
 832
 833                         info = g_strdup_printf(_("Average: %s"), buf);
 834                         gtk_label_set_text(GTK_LABEL(data->TX_info), info);
 835                         g_free(info);
 836                 }
 837         }
 838
 839         /* free our memory */
 840         g_free(tmp_amount);
 841
 842         ui_reptime_update(widget, user_data);
 843 }
 844
 845
 846 static void ui_reptime_sensitive(GtkWidget *widget, gpointer user_data)
 847 {
 848 struct ui_reptime_data *data;
 849 GtkAction *action;
 850 gboolean visible, sensitive;
 851 gint page;
 852
 853         DB( g_print("\n[reptime] sensitive\n") );
 854
 855         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 856
 857         page = gtk_notebook_get_current_page(GTK_NOTEBOOK(data->GR_result));
 858
 859         visible = page == 0 ? TRUE : FALSE;
 860         action = gtk_ui_manager_get_action(data->ui, "/ToolBar/Detail");
 861         gtk_action_set_visible (action, visible);
 862         //action = gtk_ui_manager_get_action(data->ui, "/ToolBar/Export");
 863         //gtk_action_set_visible (action, visible);
 864         //sensitive = gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_report)), NULL, NULL);
 865         //gtk_action_set_sensitive(action, sensitive);
 866         hb_widget_visible (data->BT_export, visible);
 867
 868         visible = page == 0 ? FALSE : TRUE;
 869         hb_widget_visible(data->LB_zoomx, visible);
 870         hb_widget_visible(data->RG_zoomx, visible);
 871
 872         sensitive = gtk_tree_model_iter_n_children(gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_detail)), NULL) > 0 ? TRUE : FALSE;
 873         gtk_widget_set_sensitive(data->MI_detailtoclip, sensitive);
 874         gtk_widget_set_sensitive(data->MI_detailtocsv, sensitive);
 875
 876 }
 877
 878
 879 static void ui_reptime_detail_onRowActivated (GtkTreeView        *treeview,
 880                        GtkTreePath        *path,
 881                        GtkTreeViewColumn  *col,
 882                        gpointer            userdata)
 883 {
 884 struct ui_reptime_data *data;
 885 Transaction *active_txn;
 886 gboolean result;
 887
 888         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW)), "inst_data");
 889
 890         DB( g_print ("\n[reptime] A detail row has been double-clicked!\n") );
 891
 892         active_txn = list_txn_get_active_transaction(GTK_TREE_VIEW(data->LV_detail));
 893         if(active_txn)
 894         {
 895         Transaction *old_txn, *new_txn;
 896
 897                 old_txn = da_transaction_clone (active_txn);
 898                 new_txn = active_txn;
 899                 result = deftransaction_external_edit(GTK_WINDOW(data->window), old_txn, new_txn);
 900
 901                 if(result == GTK_RESPONSE_ACCEPT)
 902                 {
 903                         //#1640885
 904                         GLOBALS->changes_count++;
 905                         ui_reptime_compute(data->window, NULL);
 906                 }
 907
 908                 da_transaction_free (old_txn);
 909         }
 910 }
 911
 912
 913 static void ui_reptime_update_detail(GtkWidget *widget, gpointer user_data)
 914 {
 915 struct ui_reptime_data *data;
 916
 917         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 918
 919         if(data->detail)
 920         {
 921         GtkTreeSelection *treeselection;
 922         GtkTreeModel *model;
 923         GtkTreeIter iter;
 924         guint key;
 925
 926                 treeselection = gtk_tree_view_get_selection (GTK_TREE_VIEW(data->LV_report));
 927
 928                 if (gtk_tree_selection_get_selected(treeselection, &model, &iter))
 929                 {
 930                         gtk_tree_model_get(model, &iter, LST_REPTIME_KEY, &key, -1);
 931
 932                         DB( g_print(" - active is %d\n", key) );
 933
 934                         ui_reptime_detail(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), GINT_TO_POINTER(key));
 935                 }
 936
 937
 938
 939                 gtk_widget_show(data->GR_detail);
 940         }
 941         else
 942                 gtk_widget_hide(data->GR_detail);
 943 }
 944
 945
 946
 947
 948 static void ui_reptime_toggle_detail(GtkWidget *widget, gpointer user_data)
 949 {
 950 struct ui_reptime_data *data;
 951
 952         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 953
 954         data->detail ^= 1;
 955
 956         DB( g_print("(stats) toggledetail to %d\n", data->detail) );
 957
 958         ui_reptime_update_detail(widget, user_data);
 959
 960 }
 961
 962 static void ui_reptime_zoomx_callback(GtkWidget *widget, gpointer user_data)
 963 {
 964 struct ui_reptime_data *data;
 965 gdouble value;
 966
 967         DB( g_print("\n[reptime] zoomx\n") );
 968
 969         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 970
 971         value = gtk_range_get_value(GTK_RANGE(data->RG_zoomx));
 972
 973         DB( g_print(" + scale is %.2f\n", value) );
 974
 975         gtk_chart_set_barw(GTK_CHART(data->RE_line), value);
 976
 977 }
 978
 979
 980
 981 static void ui_reptime_toggle_minor(GtkWidget *widget, gpointer user_data)
 982 {
 983 struct ui_reptime_data *data;
 984
 985         DB( g_print("\n[reptime] toggle\n") );
 986
 987         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 988
 989         GLOBALS->minor = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_minor));
 990
 991         //hbfile_update(data->LV_acc, (gpointer)4);
 992         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_report));
 993
 994         gtk_chart_show_minor(GTK_CHART(data->RE_line), GLOBALS->minor);
 995
 996 }
 997
 998
 999 static void ui_reptime_toggle_showall(GtkWidget *widget, gpointer user_data)
1000 {
1001 struct ui_reptime_data *data;
1002 gboolean showall;
1003
1004         DB( g_print("\n[reptime] toggle\n") );
1005
1006         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1007
1008         showall = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_all));
1009
1010         gtk_widget_set_sensitive(GTK_WIDGET(data->PO_acc), showall^1);
1011         gtk_widget_set_sensitive(GTK_WIDGET(data->PO_cat), showall^1);
1012         gtk_widget_set_sensitive(GTK_WIDGET(data->PO_pay), showall^1);
1013         gtk_widget_set_sensitive(GTK_WIDGET(data->PO_tag), showall^1);
1014
1015         ui_reptime_compute(widget, data);
1016
1017 }
1018
1019
1020
1021 /*
1022 **
1023 */
1024 static void ui_reptime_setup(struct ui_reptime_data *data, guint32 accnum)
1025 {
1026         DB( g_print("\n[reptime] setup\n") );
1027
1028         data->txn_queue = g_queue_new ();
1029
1030         data->filter = da_flt_malloc();
1031         filter_reset(data->filter);
1032
1033         data->detail = 0;
1034
1035         /* 3.4 : make int transfer out of stats */
1036         //todo: for compatibility with < 5.3, keep this unset, but normally it should be set
1037         //data->filter->option[FILTER_PAYMODE] = 1;
1038         //data->filter->paymode[PAYMODE_INTXFER] = FALSE;
1039
1040         filter_preset_daterange_set(data->filter, PREFS->date_range_rep, data->accnum);
1041
1042         g_signal_handler_block(data->PO_mindate, data->handler_id[HID_REPTIME_MINDATE]);
1043         g_signal_handler_block(data->PO_maxdate, data->handler_id[HID_REPTIME_MAXDATE]);
1044
1045         gtk_date_entry_set_date(GTK_DATE_ENTRY(data->PO_mindate), data->filter->mindate);
1046         gtk_date_entry_set_date(GTK_DATE_ENTRY(data->PO_maxdate), data->filter->maxdate);
1047
1048         g_signal_handler_unblock(data->PO_mindate, data->handler_id[HID_REPTIME_MINDATE]);
1049         g_signal_handler_unblock(data->PO_maxdate, data->handler_id[HID_REPTIME_MAXDATE]);
1050
1051
1052         DB( g_print(" populate\n") );
1053         ui_acc_comboboxentry_populate(GTK_COMBO_BOX(data->PO_acc), GLOBALS->h_acc, ACC_LST_INSERT_REPORT);
1054         if( accnum )
1055                 ui_acc_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_acc), accnum);
1056         else
1057                 gtk_combo_box_set_active(GTK_COMBO_BOX(data->PO_acc), 0);
1058
1059         ui_pay_comboboxentry_populate(GTK_COMBO_BOX(data->PO_pay), GLOBALS->h_pay);
1060         ui_pay_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_pay), 0);
1061
1062         ui_cat_comboboxentry_populate(GTK_COMBO_BOX(data->PO_cat), GLOBALS->h_cat);
1063         gtk_combo_box_set_active(GTK_COMBO_BOX(data->PO_cat), 0);
1064
1065         ui_tag_combobox_populate(GTK_COMBO_BOX_TEXT(data->PO_tag));
1066
1067         DB( g_print(" all ok\n") );
1068
1069 }
1070
1071
1072
1073 static void ui_reptime_selection(GtkTreeSelection *treeselection, gpointer user_data)
1074 {
1075 GtkTreeModel *model;
1076 GtkTreeIter iter;
1077 guint key = -1;
1078
1079         DB( g_print("\n[reptime] selection\n") );
1080
1081         if (gtk_tree_selection_get_selected(treeselection, &model, &iter))
1082         {
1083                 gtk_tree_model_get(model, &iter, LST_REPTIME_KEY, &key, -1);
1084
1085         }
1086
1087         DB( g_print(" - active is %d\n", key) );
1088
1089         ui_reptime_detail(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), GINT_TO_POINTER(key));
1090         ui_reptime_sensitive(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
1091 }
1092
1093
1094 /*
1095 **
1096 */
1097 static gboolean ui_reptime_dispose(GtkWidget *widget, GdkEvent *event, gpointer user_data)
1098 {
1099 struct ui_reptime_data *data = user_data;
1100 struct WinGeometry *wg;
1101
1102         DB( g_print("\n[reptime] dispose\n") );
1103
1104         g_queue_free (data->txn_queue);
1105
1106         da_flt_free(data->filter);
1107
1108         g_free(data);
1109
1110         //store position and size
1111         wg = &PREFS->tme_wg;
1112         gtk_window_get_position(GTK_WINDOW(widget), &wg->l, &wg->t);
1113         gtk_window_get_size(GTK_WINDOW(widget), &wg->w, &wg->h);
1114
1115         DB( g_print(" window: l=%d, t=%d, w=%d, h=%d\n", wg->l, wg->t, wg->w, wg->h) );
1116
1117
1118
1119         //enable define windows
1120         GLOBALS->define_off--;
1121         ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_SENSITIVE));
1122
1123         return FALSE;
1124 }
1125
1126 // the window creation
1127 GtkWidget *ui_reptime_window_new(guint32 accnum)
1128 {
1129 struct ui_reptime_data *data;
1130 struct WinGeometry *wg;
1131 GtkWidget *window, *mainvbox, *hbox, *vbox, *notebook, *treeview;
1132 GtkWidget *label, *widget, *table;
1133 gint row;
1134 GtkUIManager *ui;
1135 GtkActionGroup *actions;
1136 //GtkAction *action;
1137 GError *error = NULL;
1138
1139         data = g_malloc0(sizeof(struct ui_reptime_data));
1140         if(!data) return NULL;
1141
1142         DB( g_print("\n[reptime] new\n") );
1143
1144
1145         //disable define windows
1146         GLOBALS->define_off++;
1147         ui_mainwindow_update(GLOBALS->mainwindow, GINT_TO_POINTER(UF_SENSITIVE));
1148
1149     /* create window, etc */
1150     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1151         data->window = window;
1152
1153         //store our window private data
1154         g_object_set_data(G_OBJECT(window), "inst_data", (gpointer)data);
1155         DB( g_print(" - new window=%p, inst_data=%p\n", window, data) );
1156
1157
1158         gtk_window_set_title (GTK_WINDOW (window), _("Trend Time Report"));
1159
1160         //set the window icon
1161         gtk_window_set_icon_name(GTK_WINDOW (window), ICONNAME_HB_REP_TIME);
1162
1163
1164         //window contents
1165         mainvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1166         gtk_container_add (GTK_CONTAINER (window), mainvbox);
1167
1168         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
1169     gtk_box_pack_start (GTK_BOX (mainvbox), hbox, TRUE, TRUE, 0);
1170
1171         //control part
1172         table = gtk_grid_new ();
1173         gtk_widget_set_hexpand (GTK_WIDGET(table), FALSE);
1174     gtk_box_pack_start (GTK_BOX (hbox), table, FALSE, FALSE, 0);
1175
1176         gtk_container_set_border_width (GTK_CONTAINER (table), SPACING_SMALL);
1177         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_SMALL);
1178         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
1179
1180         row = 0;
1181         label = make_label_group(_("Display"));
1182         gtk_grid_attach (GTK_GRID (table), label, 0, row, 3, 1);
1183
1184         row++;
1185         label = make_label_widget(_("_View by:"));
1186         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1187         //widget = make_cycle(label, CYA_TIMESELECT);
1188         widget = hbtk_combo_box_new_with_data(label, CYA_REPORT_SRC_TREND);
1189         data->CY_src = widget;
1190         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1191
1192         row++;
1193         label = make_label_widget(_("A_ccount:"));
1194         data->LB_acc = label;
1195         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1196         widget = ui_acc_comboboxentry_new(label);
1197         data->PO_acc = widget;
1198         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1199
1200         row++;
1201         label = make_label_widget(_("_Category:"));
1202         data->LB_cat = label;
1203         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1204         widget = ui_cat_comboboxentry_new(label);
1205         data->PO_cat = widget;
1206         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1207
1208         row++;
1209         label = make_label_widget(_("_Payee:"));
1210         data->LB_pay = label;
1211         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1212         widget = ui_pay_comboboxentry_new(label);
1213         data->PO_pay = widget;
1214         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1215
1216         row++;
1217         label = make_label_widget(_("_Tag:"));
1218         data->LB_tag = label;
1219         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1220         widget = ui_tag_combobox_new(label);
1221         data->PO_tag = widget;
1222         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1223
1224         row++;
1225         widget = gtk_check_button_new_with_mnemonic (_("Select _all"));
1226         data->CM_all = widget;
1227         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1228
1229         row++;
1230         widget = gtk_check_button_new_with_mnemonic (_("_Cumulate"));
1231         data->CM_cumul = widget;
1232         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1233
1234         row++;
1235         label = make_label_widget(_("Inter_val:"));
1236         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1237         //widget = make_cycle(label, CYA_REPORT_INTVL);
1238         widget = hbtk_combo_box_new_with_data(label, CYA_REPORT_INTVL);
1239         data->CY_intvl = widget;
1240         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1241
1242         row++;
1243         widget = gtk_check_button_new_with_mnemonic (_("Show empty line"));
1244         data->CM_showempty = widget;
1245         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1246
1247
1248         row++;
1249         widget = gtk_check_button_new_with_mnemonic (_("Euro _minor"));
1250         data->CM_minor = widget;
1251         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1252
1253         row++;
1254         label = make_label_widget(_("_Zoom X:"));
1255         data->LB_zoomx = label;
1256         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1257         widget = make_scale(label);
1258         data->RG_zoomx = widget;
1259         gtk_grid_attach (GTK_GRID (table), widget, 2, row, 1, 1);
1260
1261         row++;
1262         widget = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
1263         gtk_grid_attach (GTK_GRID (table), widget, 0, row, 3, 1);
1264
1265         row++;
1266         label = make_label_group(_("Date filter"));
1267         gtk_grid_attach (GTK_GRID (table), label, 0, row, 3, 1);
1268
1269         row++;
1270         label = make_label_widget(_("_Range:"));
1271         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1272         data->CY_range = make_daterange(label, FALSE);
1273         gtk_grid_attach (GTK_GRID (table), data->CY_range, 2, row, 1, 1);
1274
1275         row++;
1276         label = make_label_widget(_("_From:"));
1277         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1278         data->PO_mindate = gtk_date_entry_new();
1279         gtk_grid_attach (GTK_GRID (table), data->PO_mindate, 2, row, 1, 1);
1280
1281         row++;
1282         label = make_label_widget(_("_To:"));
1283         gtk_grid_attach (GTK_GRID (table), label, 1, row, 1, 1);
1284         data->PO_maxdate = gtk_date_entry_new();
1285         gtk_grid_attach (GTK_GRID (table), data->PO_maxdate, 2, row, 1, 1);
1286
1287
1288         //part: info + report
1289         vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1290     gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1291
1292         //ui manager
1293         actions = gtk_action_group_new ("default");
1294
1295         //as we use gettext
1296         gtk_action_group_set_translation_domain(actions, GETTEXT_PACKAGE);
1297
1298         // data to action callbacks is set here (data)
1299         gtk_action_group_add_radio_actions (actions, radio_entries, n_radio_entries, 0, G_CALLBACK(ui_reptime_action_mode), data);
1300
1301         gtk_action_group_add_actions (actions, entries, n_entries, data);
1302
1303         gtk_action_group_add_toggle_actions (actions,
1304                                            toggle_entries, n_toggle_entries,
1305                                            data);
1306
1307
1308         /* set which action should have priority in the toolbar */
1309         //action = gtk_action_group_get_action(actions, "List");
1310         //g_object_set(action, "is_important", TRUE, NULL);
1311
1312         //action = gtk_action_group_get_action(actions, "Line");
1313         //g_object_set(action, "is_important", TRUE, NULL);
1314
1315         /*action = gtk_action_group_get_action(actions, "Column");
1316         g_object_set(action, "is_important", TRUE, NULL);*/
1317
1318         //action = gtk_action_group_get_action(actions, "Detail");
1319         //g_object_set(action, "is_important", TRUE, NULL);
1320
1321         //action = gtk_action_group_get_action(actions, "Refresh");
1322         //g_object_set(action, "is_important", TRUE, NULL);
1323
1324
1325         ui = gtk_ui_manager_new ();
1326         gtk_ui_manager_insert_action_group (ui, actions, 0);
1327         gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui));
1328
1329         if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error))
1330         {
1331                 g_message ("building UI failed: %s", error->message);
1332                 g_error_free (error);
1333         }
1334
1335         data->ui = ui;
1336         data->actions = actions;
1337
1338         //toolbar
1339         data->TB_bar = gtk_ui_manager_get_widget (ui, "/ToolBar");
1340         gtk_box_pack_start (GTK_BOX (vbox), data->TB_bar, FALSE, FALSE, 0);
1341
1342         //add export menu button
1343         GtkToolItem *toolitem;
1344         GtkWidget *menu, *menuitem, *image;
1345
1346         menu = gtk_menu_new ();
1347         //gtk_widget_set_halign (menu, GTK_ALIGN_END);
1348
1349         menuitem = gtk_menu_item_new_with_mnemonic (_("_Result to clipboard"));
1350         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1351         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_reptime_export_result_clipboard), data);
1352
1353         menuitem = gtk_menu_item_new_with_mnemonic (_("_Result to CSV"));
1354         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1355         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_reptime_export_result_csv), data);
1356
1357         menuitem = gtk_menu_item_new_with_mnemonic (_("_Detail to clipboard"));
1358         data->MI_detailtoclip = menuitem;
1359         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1360         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_reptime_export_detail_clipboard), data);
1361
1362         menuitem = gtk_menu_item_new_with_mnemonic (_("_Detail to CSV"));
1363         data->MI_detailtocsv = menuitem;
1364         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1365         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_reptime_export_detail_csv), data);
1366
1367         gtk_widget_show_all (menu);
1368
1369         widget = gtk_menu_button_new();
1370         data->BT_export = widget;
1371         gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET(widget)), GTK_STYLE_CLASS_FLAT);
1372
1373         //gtk_menu_button_set_direction (GTK_MENU_BUTTON(widget), GTK_ARROW_DOWN);
1374         //gtk_widget_set_halign (widget, GTK_ALIGN_END);
1375         image = gtk_image_new_from_icon_name (ICONNAME_HB_FILE_EXPORT, GTK_ICON_SIZE_LARGE_TOOLBAR);
1376         g_object_set (widget, "image", image, "popup", GTK_MENU(menu),  NULL);
1377
1378         toolitem = gtk_tool_item_new();
1379         gtk_container_add (GTK_CONTAINER(toolitem), widget);
1380         gtk_toolbar_insert(GTK_TOOLBAR(data->TB_bar), GTK_TOOL_ITEM(toolitem), -1);
1381
1382         //infos
1383         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1384         gtk_container_set_border_width (GTK_CONTAINER(hbox), SPACING_SMALL);
1385     gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1386
1387         label = gtk_label_new(NULL);
1388         data->TX_info = label;
1389         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1390
1391         widget = make_label(NULL, 0.5, 0.5);
1392         gimp_label_set_attributes (GTK_LABEL (widget), PANGO_ATTR_SCALE,  PANGO_SCALE_SMALL, -1);
1393         data->TX_daterange = widget;
1394         gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1395
1396
1397
1398         notebook = gtk_notebook_new();
1399         data->GR_result = notebook;
1400         gtk_widget_show(notebook);
1401         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
1402         gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
1403
1404     gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
1405
1406         //page: list
1407         vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1408         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, NULL);
1409
1410         widget = gtk_scrolled_window_new (NULL, NULL);
1411         //gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW (widget), GTK_CORNER_TOP_RIGHT);
1412         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_ETCHED_IN);
1413         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1414         treeview = ui_list_reptime_create();
1415         data->LV_report = treeview;
1416         gtk_container_add (GTK_CONTAINER(widget), treeview);
1417     gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0);
1418
1419         //detail
1420         widget = gtk_scrolled_window_new (NULL, NULL);
1421         data->GR_detail = widget;
1422         //gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW (widget), GTK_CORNER_TOP_RIGHT);
1423         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_ETCHED_IN);
1424         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1425         treeview = create_list_transaction(LIST_TXN_TYPE_DETAIL, PREFS->lst_ope_columns);
1426         data->LV_detail = treeview;
1427         gtk_container_add (GTK_CONTAINER(widget), treeview);
1428
1429     gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0);
1430
1431
1432         //page: lines
1433         widget = gtk_chart_new(CHART_TYPE_LINE);
1434         data->RE_line = widget;
1435         //gtk_chart_set_minor_prefs(GTK_CHART(widget), PREFS->euro_value, PREFS->minor_cur.suffix_symbol);
1436         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), widget, NULL);
1437
1438         //todo:should move this
1439         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_minor), GLOBALS->minor);
1440
1441         //duplicate, see below
1442         //gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_intvl), 1);
1443
1444         /* attach our minor to treeview */
1445         g_object_set_data(G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_report))), "minor", (gpointer)data->CM_minor);
1446         g_object_set_data(G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_detail))), "minor", (gpointer)data->CM_minor);
1447
1448
1449
1450         /* signal connect */
1451         g_signal_connect (window, "delete-event", G_CALLBACK (ui_reptime_dispose), (gpointer)data);
1452
1453         g_signal_connect (data->CM_cumul, "toggled", G_CALLBACK (ui_reptime_compute), NULL);
1454
1455         g_signal_connect (data->CM_minor, "toggled", G_CALLBACK (ui_reptime_toggle_minor), NULL);
1456
1457         data->handler_id[HID_REPTIME_MINDATE] = g_signal_connect (data->PO_mindate, "changed", G_CALLBACK (ui_reptime_date_change), (gpointer)data);
1458         data->handler_id[HID_REPTIME_MAXDATE] = g_signal_connect (data->PO_maxdate, "changed", G_CALLBACK (ui_reptime_date_change), (gpointer)data);
1459
1460         data->handler_id[HID_REPTIME_RANGE] = g_signal_connect (data->CY_range, "changed", G_CALLBACK (ui_reptime_range_change), NULL);
1461
1462         g_signal_connect (data->CY_src, "changed", G_CALLBACK (ui_reptime_for), (gpointer)data);
1463         data->handler_id[HID_REPTIME_VIEW] = g_signal_connect (data->CY_intvl, "changed", G_CALLBACK (ui_reptime_compute), (gpointer)data);
1464
1465         g_signal_connect (data->CM_showempty, "toggled", G_CALLBACK (ui_reptime_compute), NULL);
1466
1467         //setup, init and show window
1468         ui_reptime_setup(data, accnum);
1469
1470         g_signal_connect (data->CM_all, "toggled", G_CALLBACK (ui_reptime_toggle_showall), NULL);
1471         g_signal_connect (data->PO_acc, "changed", G_CALLBACK (ui_reptime_compute), NULL);
1472         g_signal_connect (data->PO_cat, "changed", G_CALLBACK (ui_reptime_compute), NULL);
1473         g_signal_connect (data->PO_pay, "changed", G_CALLBACK (ui_reptime_compute), NULL);
1474         g_signal_connect (data->PO_tag, "changed", G_CALLBACK (ui_reptime_compute), NULL);
1475
1476         g_signal_connect (data->RG_zoomx, "value-changed", G_CALLBACK (ui_reptime_zoomx_callback), NULL);
1477
1478
1479         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_report)), "changed", G_CALLBACK (ui_reptime_selection), NULL);
1480
1481         g_signal_connect (GTK_TREE_VIEW(data->LV_detail), "row-activated", G_CALLBACK (ui_reptime_detail_onRowActivated), NULL);
1482
1483
1484         /* toolbar */
1485         if(PREFS->toolbar_style == 0)
1486                 gtk_toolbar_unset_style(GTK_TOOLBAR(data->TB_bar));
1487         else
1488                 gtk_toolbar_set_style(GTK_TOOLBAR(data->TB_bar), PREFS->toolbar_style-1);
1489
1490         //setup, init and show window
1491         wg = &PREFS->tme_wg;
1492         gtk_window_move(GTK_WINDOW(window), wg->l, wg->t);
1493         gtk_window_resize(GTK_WINDOW(window), wg->w, wg->h);
1494
1495         //todo: !! here
1496         hbtk_combo_box_set_active_id(GTK_COMBO_BOX_TEXT(data->CY_intvl), REPORT_INTVL_MONTH);
1497
1498         gtk_widget_show_all (window);
1499
1500         //minor ?
1501         if( PREFS->euro_active )
1502                 gtk_widget_show(data->CM_minor);
1503         else
1504                 gtk_widget_hide(data->CM_minor);
1505
1506         ui_reptime_update_for(window, data);
1507         //gtk_widget_hide(data->GR_detail);
1508
1509
1510
1511         ui_reptime_sensitive(window, NULL);
1512         ui_reptime_update_detail(window, NULL);
1513
1514         DB( g_print("range: %d\n", PREFS->date_range_rep) );
1515
1516         if( PREFS->date_range_rep != 0)
1517                 gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_range), PREFS->date_range_rep);
1518         else
1519                 ui_reptime_compute(window, NULL);
1520
1521         return window;
1522 }
1523
1524
1525 /*
1526 ** ============================================================================
1527 */
1528
1529
1530 static GString *ui_list_reptime_to_string(GtkTreeView *treeview, gboolean clipboard)
1531 {
1532 GString *node;
1533 GtkTreeModel *model;
1534 GtkTreeIter     iter;
1535 gboolean valid;
1536 const gchar *format;
1537
1538         node = g_string_new(NULL);
1539
1540         // header
1541         format = (clipboard == TRUE) ? "%s\t%s\n" : "%s;%s\n";
1542         g_string_append_printf(node, format, _("Time slice"), _("Amount"));
1543
1544         model = gtk_tree_view_get_model(treeview);
1545         valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
1546         while (valid)
1547         {
1548         gchar *name;
1549         gdouble amount;
1550
1551                 gtk_tree_model_get (model, &iter,
1552                         //LST_REPTIME_KEY, i,
1553                         LST_REPTIME_TITLE  , &name,
1554                         LST_REPTIME_AMOUNT , &amount,
1555                         -1);
1556
1557                 format = (clipboard == TRUE) ? "%s\t%.2f\n" : "%s;%.2f\n";
1558                 g_string_append_printf(node, format, name, amount);
1559
1560                 //leak
1561                 g_free(name);
1562
1563                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
1564         }
1565
1566         //DB( g_print("text is:\n%s", node->str) );
1567
1568         return node;
1569 }
1570
1571
1572 static void ui_reptime_amount_cell_data_function (GtkTreeViewColumn *col,
1573                            GtkCellRenderer   *renderer,
1574                            GtkTreeModel      *model,
1575                            GtkTreeIter       *iter,
1576                            gpointer           user_data)
1577 {
1578 gdouble  value;
1579 gchar *color;
1580 gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
1581 guint32 kcur = GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(gtk_tree_view_column_get_tree_view(col)), "kcur_data"));
1582
1583         gtk_tree_model_get(model, iter, GPOINTER_TO_INT(user_data), &value, -1);
1584
1585         if( value )
1586         {
1587                 hb_strfmon(buf, G_ASCII_DTOSTR_BUF_SIZE-1, value, kcur, GLOBALS->minor);
1588
1589                 color = get_normal_color_amount(value);
1590
1591                 g_object_set(renderer,
1592                         "foreground",  color,
1593                         "text", buf,
1594                         NULL);  }
1595         else
1596         {
1597                 g_object_set(renderer, "text", "", NULL);
1598         }
1599 }
1600
1601
1602 static GtkTreeViewColumn *amount_list_ui_reptime_column(gchar *name, gint id)
1603 {
1604 GtkTreeViewColumn  *column;
1605 GtkCellRenderer    *renderer;
1606
1607         column = gtk_tree_view_column_new();
1608         gtk_tree_view_column_set_title(column, name);
1609         renderer = gtk_cell_renderer_text_new ();
1610         g_object_set(renderer, "xalign", 1.0, NULL);
1611         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1612         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_reptime_amount_cell_data_function, GINT_TO_POINTER(id), NULL);
1613         gtk_tree_view_column_set_alignment (column, 0.5);
1614         //gtk_tree_view_column_set_sort_column_id (column, id);
1615         return column;
1616 }
1617
1618
1619 static void ui_reptime_list_set_cur(GtkTreeView *treeview, guint32 kcur)
1620 {
1621         g_object_set_data(G_OBJECT(treeview), "kcur_data", GUINT_TO_POINTER(kcur));
1622 }
1623
1624
1625 /*
1626 ** create our statistic list
1627 */
1628 static GtkWidget *ui_list_reptime_create(void)
1629 {
1630 GtkListStore *store;
1631 GtkWidget *view;
1632 GtkCellRenderer    *renderer;
1633 GtkTreeViewColumn  *column;
1634
1635         /* create list store */
1636         store = gtk_list_store_new(
1637                 NUM_LST_REPTIME,
1638                 G_TYPE_INT,
1639                 G_TYPE_INT,
1640                 G_TYPE_STRING,
1641                 G_TYPE_DOUBLE
1642                 );
1643
1644         //treeview
1645         view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
1646         g_object_unref(store);
1647
1648         gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (view), PREFS->grid_lines);
1649
1650         /* column: Name */
1651         column = gtk_tree_view_column_new();
1652         gtk_tree_view_column_set_title(column, _("Time slice"));
1653         renderer = gtk_cell_renderer_text_new ();
1654         g_object_set(renderer, "xalign", 1.0, NULL);
1655         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1656         //gtk_tree_view_column_set_cell_data_func(column, renderer, ope_result_cell_data_function, NULL, NULL);
1657         gtk_tree_view_column_add_attribute(column, renderer, "text", LST_REPTIME_TITLE);
1658         //gtk_tree_view_column_set_sort_column_id (column, LST_REPTIME_NAME);
1659         gtk_tree_view_column_set_resizable(column, TRUE);
1660         gtk_tree_view_column_set_alignment (column, 0.5);
1661         gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1662
1663         /* column: Amount */
1664         column = amount_list_ui_reptime_column(_("Amount"), LST_REPTIME_AMOUNT);
1665         gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1666
1667   /* column last: empty */
1668         column = gtk_tree_view_column_new();
1669         gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
1670
1671         /* sort */
1672         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_REPTIME_POS    , ui_list_reptime_compare_func, GINT_TO_POINTER(LST_REPTIME_POS), NULL);
1673         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_REPTIME_AMOUNT, ui_list_reptime_compare_func, GINT_TO_POINTER(LST_REPTIME_AMOUNT), NULL);
1674
1675         return(view);
1676 }
1677
1678 static gint ui_list_reptime_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
1679 {
1680 gint sortcol = GPOINTER_TO_INT(userdata);
1681 gint retval = 0;
1682 gint pos1, pos2;
1683 gdouble val1, val2;
1684
1685         gtk_tree_model_get(model, a,
1686                 LST_REPTIME_POS, &pos1,
1687                 sortcol, &val1,
1688                 -1);
1689         gtk_tree_model_get(model, b,
1690                 LST_REPTIME_POS, &pos2,
1691                 sortcol, &val2,
1692                 -1);
1693 /*
1694         if(pos1 == -1) return(1);
1695         if(pos2 == -1) return(-1);
1696 */
1697
1698         if(sortcol == LST_REPTIME_POS)
1699                 retval = pos2 - pos1;
1700         else
1701                 retval = (ABS(val1) - ABS(val2)) > 0 ? 1 : -1;
1702
1703         //DB( g_print(" sort %d=%d or %.2f=%.2f :: %d\n", pos1,pos2, val1, val2, ret) );
1704
1705     return retval;
1706   }
1707
1708
1709