Dogcows Code - chaz/homebank/blob - src/ui-archive.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 "ui-archive.h"
  24 #include "ui-account.h"
  25 #include "ui-category.h"
  26 #include "ui-payee.h"
  27 #include "ui-split.h"
  28 #include "ui-tag.h"
  29
  30 #include "gtk-dateentry.h"
  31
  32 /****************************************************************************/
  33 /* Debug macros                                                             */
  34 /****************************************************************************/
  35 #define MYDEBUG 0
  36
  37 #if MYDEBUG
  38 #define DB(x) (x);
  39 #else
  40 #define DB(x);
  41 #endif
  42
  43 /* our global datas */
  44 extern struct HomeBank *GLOBALS;
  45 extern struct Preferences *PREFS;
  46
  47
  48 extern gchar *RA_ARC_TYPE[];
  49 extern gchar *CYA_ARC_UNIT[];
  50 extern gchar *RA_ARC_WEEKEND[];
  51 extern gchar *CYA_TXN_STATUS[];
  52
  53
  54
  55 static GtkWidget *ui_arc_listview_new(void);
  56
  57
  58 static void ui_arc_listview_populate(GtkWidget *view, gint type)
  59 {
  60 GtkTreeModel *model;
  61 GtkTreeIter  iter;
  62 GList *list;
  63 gint i;
  64
  65         DB( g_print("ui_arc_listview_populate()\n") );
  66
  67         DB( g_print(" - type=%d\n", type) );
  68
  69
  70         //insert all glist item into treeview
  71         model  = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
  72
  73
  74         gtk_list_store_clear (GTK_LIST_STORE(model));
  75
  76         i=0;
  77         list = g_list_first(GLOBALS->arc_list);
  78         while (list != NULL)
  79         {
  80         Archive *item = list->data;
  81
  82                 if( (type == ARC_TYPE_SCHEDULED) && !(item->flags & OF_AUTO) )
  83                         goto next;
  84
  85                 if( (type == ARC_TYPE_TEMPLATE) && (item->flags & OF_AUTO) )
  86                         goto next;
  87
  88                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
  89                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
  90                         LST_DEFARC_DATAS, item, //data struct
  91                         LST_DEFARC_OLDPOS, i,           //oldpos
  92                         -1);
  93
  94                 //DB( g_print(" populate_treeview: %d %08x\n", i, list->data) );
  95 next:
  96                 i++; list = g_list_next(list);
  97         }
  98
  99 }
 100
 101
 102 static void ui_arc_listview_select_by_pointer(GtkTreeView *treeview, gpointer user_data)
 103 {
 104 GtkTreeModel *model;
 105 GtkTreeIter     iter;
 106 GtkTreeSelection *selection;
 107 gboolean valid;
 108 Archive *arc = user_data;
 109
 110         model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
 111         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
 112
 113         valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
 114         while (valid)
 115         {
 116         Archive *tmp_arc;
 117
 118                 gtk_tree_model_get (model, &iter, LST_DEFARC_DATAS, &tmp_arc, -1);
 119                 if( arc == tmp_arc )
 120                 {
 121                         gtk_tree_selection_select_iter (selection, &iter);
 122                         break;
 123                 }
 124
 125                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
 126         }
 127 }
 128
 129
 130 /*
 131 **
 132 ** The function should return:
 133 ** a negative integer if the first value comes before the second,
 134 ** 0 if they are equal,
 135 ** or a positive integer if the first value comes after the second.
 136 */
 137 static gint ui_arc_listview_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
 138 {
 139 gint sortcol = GPOINTER_TO_INT(userdata);
 140 Archive *entry1, *entry2;
 141 gint retval = 0;
 142
 143         gtk_tree_model_get(model, a, LST_DEFARC_DATAS, &entry1, -1);
 144         gtk_tree_model_get(model, b, LST_DEFARC_DATAS, &entry2, -1);
 145
 146     switch (sortcol)
 147     {
 148                 case LST_DEFARC_SORT_MEMO:
 149                         retval = (entry1->flags & GF_INCOME) - (entry2->flags & GF_INCOME);
 150                         if(!retval)
 151                         {
 152                                 retval = hb_string_utf8_compare(entry1->memo, entry2->memo);
 153                         }
 154                         break;
 155                 case LST_DEFARC_SORT_PAYEE:
 156                         {
 157                         Payee *p1, *p2;
 158
 159                                 p1 = da_pay_get(entry1->kpay);
 160                                 p2 = da_pay_get(entry2->kpay);
 161                                 if( p1 != NULL && p2 != NULL )
 162                                 {
 163                                         retval = hb_string_utf8_compare(p1->name, p2->name);
 164                                 }
 165                         }
 166                         break;
 167                 default:
 168                         g_return_val_if_reached(0);
 169         }
 170     return retval;
 171 }
 172
 173
 174 /*
 175 **
 176 */
 177 static void ui_arc_listview_auto_cell_data_function (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
 178 {
 179 Archive *item;
 180 gchar *iconname = NULL;
 181
 182         // get the transaction
 183         gtk_tree_model_get(model, iter, LST_DEFARC_DATAS, &item, -1);
 184
 185         iconname = ( item->flags & OF_AUTO ) ? ICONNAME_HB_OPE_AUTO : NULL;
 186
 187         g_object_set(renderer, "icon-name", iconname, NULL);
 188 }
 189
 190
 191 /*
 192 ** draw some text from the stored data structure
 193 */
 194 static void ui_arc_listview_cell_data_function_memo (GtkTreeViewColumn *col,
 195                                 GtkCellRenderer *renderer,
 196                                 GtkTreeModel *model,
 197                                 GtkTreeIter *iter,
 198                                 gpointer user_data)
 199 {
 200 Archive *item;
 201 gchar *name;
 202 #if MYDEBUG
 203 gchar *string;
 204 #endif
 205
 206         gtk_tree_model_get(model, iter, LST_DEFARC_DATAS, &item, -1);
 207
 208         name = item->memo;
 209
 210         #if MYDEBUG
 211                 string = g_strdup_printf ("[%d] %s", item->key, name );
 212                 g_object_set(renderer, "text", string, NULL);
 213                 g_free(string);
 214         #else
 215                 g_object_set(renderer, "text", name, NULL);
 216         #endif
 217 }
 218
 219
 220
 221 static void ui_arc_listview_cell_data_function_payee (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
 222 {
 223 Archive *arc;
 224 Payee *pay;
 225
 226         gtk_tree_model_get(model, iter,
 227                 LST_DEFARC_DATAS, &arc,
 228                 -1);
 229
 230         if(arc)
 231         {
 232
 233                 pay = da_pay_get(arc->kpay);
 234
 235                 if(pay != NULL)
 236                         g_object_set(renderer, "text", pay->name, NULL);
 237         }
 238                 else
 239                 g_object_set(renderer, "text", NULL, NULL);
 240
 241 }
 242
 243 /*
 244 **
 245 */
 246 static GtkWidget *ui_arc_listview_new(void)
 247 {
 248 GtkListStore *store;
 249 GtkWidget *view;
 250 GtkCellRenderer    *renderer;
 251 GtkTreeViewColumn  *column;
 252
 253         //store
 254         store = gtk_list_store_new (
 255                 NUM_LST_DEFARC,
 256                 G_TYPE_POINTER,
 257                 G_TYPE_UINT,
 258                 G_TYPE_BOOLEAN
 259                 );
 260
 261         //treeview
 262         view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 263         g_object_unref(store);
 264
 265         gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (view), PREFS->grid_lines);
 266
 267         /* column: Memo */
 268         renderer = gtk_cell_renderer_text_new ();
 269         g_object_set(renderer,
 270                 "ellipsize", PANGO_ELLIPSIZE_END,
 271             "ellipsize-set", TRUE,
 272             NULL);
 273
 274         column = gtk_tree_view_column_new();
 275         gtk_tree_view_column_set_title(column, _("Memo"));
 276         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 277         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_arc_listview_cell_data_function_memo, GINT_TO_POINTER(LST_DEFARC_SORT_MEMO), NULL);
 278         gtk_tree_view_column_set_sort_column_id (column, LST_DEFARC_SORT_MEMO);
 279         gtk_tree_view_column_set_alignment (column, 0.5);
 280         gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST);
 281         gtk_tree_view_column_set_resizable(column, TRUE);
 282         gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
 283
 284         /* column: Payee */
 285         renderer = gtk_cell_renderer_text_new ();
 286         g_object_set(renderer,
 287                 "ellipsize", PANGO_ELLIPSIZE_END,
 288             "ellipsize-set", TRUE,
 289             NULL);
 290         column = gtk_tree_view_column_new();
 291         gtk_tree_view_column_set_title(column, _("Payee"));
 292         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 293         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_arc_listview_cell_data_function_payee, GINT_TO_POINTER(LST_DEFARC_SORT_PAYEE), NULL);
 294         gtk_tree_view_column_set_resizable(column, TRUE);
 295         //gtk_tree_view_column_add_attribute(column, renderer, "text", 1);
 296         gtk_tree_view_column_set_sort_column_id (column, LST_DEFARC_SORT_PAYEE);
 297         gtk_tree_view_column_set_alignment (column, 0.5);
 298         gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST);
 299         gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
 300
 301
 302         /* column: Scheduled icon */
 303         column = gtk_tree_view_column_new();
 304         renderer = gtk_cell_renderer_pixbuf_new ();
 305         //gtk_cell_renderer_set_fixed_size(renderer, GLOBALS->lst_pixbuf_maxwidth, -1);
 306         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 307         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_arc_listview_auto_cell_data_function, NULL, NULL);
 308         gtk_tree_view_append_column (GTK_TREE_VIEW(view), column);
 309
 310
 311         //sortable
 312         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DEFARC_SORT_MEMO, ui_arc_listview_compare_func, GINT_TO_POINTER(LST_DEFARC_SORT_MEMO), NULL);
 313         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DEFARC_SORT_PAYEE, ui_arc_listview_compare_func, GINT_TO_POINTER(LST_DEFARC_SORT_PAYEE), NULL);
 314
 315
 316         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), LST_DEFARC_SORT_MEMO, GTK_SORT_ASCENDING);
 317
 318         //gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(view), FALSE);
 319         //gtk_tree_view_set_reorderable (GTK_TREE_VIEW(view), TRUE);
 320
 321         return(view);
 322 }
 323
 324
 325 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 326
 327
 328
 329 /*
 330 ** add an empty new account to our temp GList and treeview
 331 */
 332 static void ui_arc_manage_add(GtkWidget *widget, gpointer user_data)
 333 {
 334 struct ui_arc_manage_data *data;
 335 GtkTreeModel *model;
 336 GtkTreeIter  iter;
 337 Archive *item;
 338 gint type;
 339
 340         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 341         DB( g_print("\n[ui_scheduled] add\n") );
 342
 343         model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_arc));
 344
 345         item = da_archive_malloc();
 346         item->memo = g_strdup_printf(_("(template %d)"), g_list_length(GLOBALS->arc_list) + 1);
 347         item->unit = 2;
 348
 349         type = hbtk_radio_get_active(GTK_CONTAINER(data->RA_type)) == 1 ? ARC_TYPE_TEMPLATE : ARC_TYPE_SCHEDULED;
 350         if( type == ARC_TYPE_SCHEDULED )
 351                 item->flags |= OF_AUTO;
 352
 353         //GLOBALS->arc_list = g_list_append(GLOBALS->arc_list, item);
 354         da_archive_append_new(item);
 355
 356         gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 357         gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 358                 LST_DEFARC_DATAS, item,
 359                 LST_DEFARC_OLDPOS, 0,
 360                 -1);
 361
 362         gtk_tree_selection_select_iter (gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_arc)), &iter);
 363
 364         data->change++;
 365 }
 366
 367 /*
 368 ** delete the selected account to our treeview and temp GList
 369 */
 370 static void ui_arc_manage_delete(GtkWidget *widget, gpointer user_data)
 371 {
 372 struct ui_arc_manage_data *data;
 373 GtkTreeSelection *selection;
 374 GtkTreeModel             *model;
 375 GtkTreeIter                      iter;
 376 Archive *item;
 377 gint result;
 378
 379         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 380         DB( g_print("\n[ui_scheduled] delete (data=%p)\n", data) );
 381
 382         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_arc));
 383         //if true there is a selected node
 384         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 385         {
 386         gchar *title;
 387         gchar *secondtext;
 388
 389                 gtk_tree_model_get(model, &iter, LST_DEFARC_DATAS, &item, -1);
 390
 391                 title = g_strdup_printf (
 392                         _("Are you sure you want to permanently delete '%s'?"), item->memo);
 393
 394                 secondtext = _("If you delete a scheduled/template, it will be permanently lost.");
 395
 396                 result = ui_dialog_msg_confirm_alert(
 397                                 GTK_WINDOW(data->window),
 398                                 title,
 399                                 secondtext,
 400                                 _("_Delete")
 401                         );
 402
 403                 g_free(title);
 404
 405                 if( result == GTK_RESPONSE_OK )
 406                 {
 407                         gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 408
 409                         GLOBALS->arc_list = g_list_remove(GLOBALS->arc_list, item);
 410
 411                         data->change++;
 412
 413                 }
 414                 //DB( g_print(" delete =%08x (pos=%d)\n", entry, g_list_index(data->tmp_list, entry) ) );
 415         }
 416 }
 417
 418
 419 /*
 420 ** update the archive name everytime it changes
 421 */
 422 static void ui_arc_manage_rename(GtkWidget *widget, gpointer user_data)
 423 {
 424 struct ui_arc_manage_data *data;
 425 GtkTreeSelection *selection;
 426 GtkTreeModel             *model;
 427 GtkTreeIter                      iter;
 428 gchar *txt;
 429 Archive *item;
 430
 431         DB( g_print("\n[ui_scheduled] rename\n") );
 432
 433         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 434
 435         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_arc));
 436         //if true there is a selected node
 437         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 438         {
 439                 gtk_tree_model_get(model, &iter, LST_DEFARC_DATAS, &item, -1);
 440
 441                 DB( g_print(" -> %s\n", item->memo) );
 442
 443                 txt = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_word));
 444                 // ignore if entry is empty
 445                 if (txt && *txt)
 446                 {
 447                         g_free(item->memo);
 448                         item->memo = g_strdup(txt);
 449                 }
 450
 451                 gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_arc));
 452
 453         }
 454
 455 }
 456
 457
 458
 459
 460 /*
 461 ** set widgets contents from the selected account
 462 */
 463 static void ui_arc_manage_set(GtkWidget *widget, gpointer user_data)
 464 {
 465 struct ui_arc_manage_data *data;
 466 GtkTreeSelection *selection;
 467 GtkTreeModel             *model;
 468 GtkTreeIter                      iter;
 469 Archive *item;
 470 gchar *tagstr, *txt;
 471
 472         DB( g_print("\n[ui_scheduled] set\n") );
 473
 474         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 475
 476         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_arc));
 477         //if true there is a selected node
 478         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 479         {
 480                 gtk_tree_model_get(model, &iter, LST_DEFARC_DATAS, &item, -1);
 481
 482                 g_signal_handler_block(data->ST_word, data->handler_id[HID_ARC_MEMO]);
 483                 gtk_entry_set_text(GTK_ENTRY(data->ST_word), item->memo);
 484                 g_signal_handler_unblock(data->ST_word, data->handler_id[HID_ARC_MEMO]);
 485
 486                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_amount), item->amount);
 487
 488                 hbtk_radio_set_active(GTK_CONTAINER(data->RA_status), item->status );
 489
 490
 491                 /*g_signal_handler_block(data->CM_valid, data->handler_id[HID_ARC_VALID]);
 492                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_valid), (item->flags & OF_VALID) ? 1 : 0);
 493                 g_signal_handler_unblock(data->CM_valid, data->handler_id[HID_ARC_VALID]);
 494
 495                 g_signal_handler_block(data->CM_remind, data->handler_id[HID_ARC_REMIND]);
 496                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_remind), (item->flags & OF_REMIND) ? 1 : 0);
 497                 g_signal_handler_unblock(data->CM_remind, data->handler_id[HID_ARC_REMIND]);
 498                 */
 499
 500                 gtk_combo_box_set_active(GTK_COMBO_BOX(data->NU_mode), item->paymode);
 501
 502                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_cheque), (item->flags & OF_CHEQ2) ? 1 : 0);
 503
 504                 ui_cat_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_grp), item->kcat);
 505
 506                 DB( g_print(" -> set payee %d\n", item->kpay) );
 507                 ui_pay_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_pay), item->kpay);
 508
 509                 DB( g_print(" -> PO_acc %d\n", item->kacc) );
 510                 ui_acc_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_acc), item->kacc);
 511
 512                 DB( g_print(" -> PO_accto %d\n", item->kxferacc) );
 513                 ui_acc_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_accto), item->kxferacc);
 514
 515                 tagstr = tags_tostring(item->tags);
 516                 txt = (tagstr != NULL) ? tagstr : "";
 517                 DB( g_print(" - tags: '%s'\n", txt) );
 518                 gtk_entry_set_text(GTK_ENTRY(data->ST_tags), txt);
 519                 g_free(tagstr);
 520
 521                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_auto), (item->flags & OF_AUTO) ? 1 : 0);
 522                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->NB_every), item->every);
 523                 gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_unit), item->unit);
 524                 gtk_date_entry_set_date(GTK_DATE_ENTRY(data->PO_next), item->nextdate);
 525                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_limit), (item->flags & OF_LIMIT) ? 1 : 0);
 526                 DB( g_print("nb_limit = %d %g\n", item->limit, (gdouble)item->limit) );
 527                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->NB_limit), (gdouble)item->limit);
 528                 hbtk_radio_set_active(GTK_CONTAINER(data->CY_weekend), item->weekend);
 529         }
 530 }
 531
 532
 533 /*
 534 ** get widgets contents to the selected account
 535 */
 536 static void ui_arc_manage_getlast(struct ui_arc_manage_data *data)
 537 {
 538 Archive *item;
 539 gchar *txt;
 540 gdouble value;
 541 gint active;
 542
 543
 544         DB( g_print("\n[ui_scheduled] getlast\n") );
 545
 546         item = data->lastarcitem;
 547
 548         if( item != NULL )
 549         {
 550                 DB( g_print(" -> %s\n", item->memo) );
 551
 552                 gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_arc));
 553
 554                 txt = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_word));
 555                 // ignore if entry is empty
 556                 if (txt && *txt)
 557                 {
 558                         g_free(item->memo);
 559                         item->memo = g_strdup(txt);
 560                 }
 561
 562                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->ST_amount));
 563                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_amount));
 564                 item->amount = value;
 565
 566                 item->paymode   = gtk_combo_box_get_active(GTK_COMBO_BOX(data->NU_mode));
 567                 item->kcat              = ui_cat_comboboxentry_get_key_add_new(GTK_COMBO_BOX(data->PO_grp));
 568                 item->kpay              = ui_pay_comboboxentry_get_key_add_new(GTK_COMBO_BOX(data->PO_pay));
 569                 item->kacc              = ui_acc_comboboxentry_get_key(GTK_COMBO_BOX(data->PO_acc));
 570                 item->kxferacc  = ui_acc_comboboxentry_get_key(GTK_COMBO_BOX(data->PO_accto));
 571
 572                 item->status = hbtk_radio_get_active(GTK_CONTAINER(data->RA_status));
 573
 574                 /* tags */
 575                 txt = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_tags));
 576                 DB( g_print(" - tags: '%s'\n", txt) );
 577                 g_free(item->tags);
 578                 item->tags = tags_parse(txt);
 579
 580                 //#1615245: moved here, after get combo entry key
 581                 if( item->paymode != PAYMODE_INTXFER )
 582                 {
 583                         //#677351: revert kxferacc to 0
 584                         item->kxferacc = 0;
 585                 }
 586
 587                 /* flags */
 588                 //item->flags = 0;
 589                 item->flags &= (OF_SPLIT);      //(split is set in hb_archive)
 590
 591                 active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_cheque));
 592                 if(active == 1) item->flags |= OF_CHEQ2;
 593
 594                 //active = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_amount));
 595                 active = item->amount > 0 ? TRUE : FALSE;
 596                 if(active == TRUE) item->flags |= OF_INCOME;
 597
 598
 599                 /* -- automated -- */
 600
 601                 active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_auto));
 602                 if(active == 1) item->flags |= OF_AUTO;
 603
 604                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->NB_every));
 605                 item->every   = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(data->NB_every));
 606                 item->unit    = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_unit));
 607                 item->nextdate  = gtk_date_entry_get_date(GTK_DATE_ENTRY(data->PO_next));
 608
 609                 active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_limit));
 610                 if(active == 1) item->flags |= OF_LIMIT;
 611
 612                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->NB_limit));
 613                 item->limit   = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(data->NB_limit));
 614
 615                 item->weekend = hbtk_radio_get_active(GTK_CONTAINER(data->CY_weekend));
 616
 617                 data->change++;
 618         }
 619 }
 620
 621
 622 static void ui_arc_manage_update_accto(GtkWidget *widget, gpointer user_data)
 623 {
 624 struct ui_arc_manage_data *data;
 625 guint kacc, kdst;
 626
 627         DB( g_print("\n\n[ui_scheduled] update accto\n") );
 628
 629         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 630
 631         kacc = ui_acc_comboboxentry_get_key(GTK_COMBO_BOX(data->PO_acc));
 632         kdst = ui_acc_comboboxentry_get_key(GTK_COMBO_BOX(data->PO_accto));
 633
 634         DB( g_print(" ksrc=%d, kdst=%d\n", kacc, kdst) );
 635
 636         ui_acc_comboboxentry_populate_except(GTK_COMBO_BOX(data->PO_accto), GLOBALS->h_acc, kacc, ACC_LST_INSERT_NORMAL);
 637
 638         if( (kacc == 0) || (kacc == kdst) )
 639         {
 640                 ui_acc_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_accto), 0);
 641         }
 642
 643 }
 644
 645
 646 /*
 647 **
 648 */
 649 static void ui_arc_manage_paymode(GtkWidget *widget, gpointer user_data)
 650 {
 651 struct ui_arc_manage_data *data;
 652 gint payment;
 653 gint page;
 654 gboolean sensitive;
 655
 656         DB( g_print("\n[ui_scheduled] paymode\n") );
 657
 658         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 659
 660         //DB( g_print(" widget=%p, data=%p\n", widget, data) );
 661
 662
 663         payment = gtk_combo_box_get_active(GTK_COMBO_BOX(data->NU_mode));
 664         page = 0;
 665
 666         if(payment == PAYMODE_CHECK)
 667                 page = 1;
 668
 669         sensitive = page == 1 ? TRUE : FALSE;
 670         hb_widget_visible(data->CM_cheque, sensitive);
 671
 672         if(payment == PAYMODE_INTXFER)
 673         {
 674                 page = 2;
 675                 ui_arc_manage_update_accto(widget, user_data);
 676         }
 677
 678         DB( g_print(" payment: %d, page: %d\n", payment, page) );
 679
 680         sensitive = page == 2 ? TRUE : FALSE;
 681         hb_widget_visible(data->LB_accto, sensitive);
 682         hb_widget_visible(data->PO_accto, sensitive);
 683
 684         DB( g_print(" visible: %d\n", sensitive) );
 685
 686 }
 687
 688 /*
 689 **
 690 */
 691 static void ui_arc_manage_scheduled(GtkWidget *widget, gpointer user_data)
 692 {
 693 struct ui_arc_manage_data *data;
 694 Archive *arcitem;
 695 GtkTreeModel             *model;
 696 GtkTreeIter                      iter;
 697 GtkTreePath                     *path;
 698 gboolean selected, sensitive;
 699
 700         DB( g_print("\n[ui_scheduled] scheduled\n") );
 701
 702         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 703
 704         sensitive = FALSE;
 705
 706
 707         selected = gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_arc)), &model, &iter);
 708         if(selected)
 709         {
 710                 gtk_tree_model_get(model, &iter, LST_DEFARC_DATAS, &arcitem, -1);
 711
 712                 arcitem->flags &= ~(OF_AUTO);
 713                 sensitive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_auto)) ? TRUE : FALSE;
 714                 if(sensitive)
 715                         arcitem->flags |= OF_AUTO;
 716         }
 717
 718
 719
 720         gtk_widget_set_sensitive(data->LB_next, sensitive);
 721         gtk_widget_set_sensitive(data->PO_next, sensitive);
 722
 723         gtk_widget_set_sensitive(data->LB_every, sensitive);
 724         gtk_widget_set_sensitive(data->NB_every, sensitive);
 725
 726         gtk_widget_set_sensitive(data->LB_weekend, sensitive);
 727         gtk_widget_set_sensitive(data->CY_weekend, sensitive);
 728
 729         gtk_widget_set_sensitive(data->CY_unit, sensitive);
 730         gtk_widget_set_sensitive(data->CM_limit, sensitive);
 731
 732         gtk_widget_set_sensitive(data->LB_posts, sensitive);
 733
 734
 735         sensitive = (sensitive == TRUE) ? gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_limit)) : sensitive;
 736         gtk_widget_set_sensitive(data->NB_limit, sensitive);
 737
 738         if(selected)
 739         {
 740                 /* redraw the row to display/hide the icon */
 741                 path = gtk_tree_model_get_path(model, &iter);
 742                 gtk_tree_model_row_changed(model, path, &iter);
 743                 gtk_tree_path_free (path);
 744
 745                 //      gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_arc));
 746                 //gtk_widget_queue_draw (GTK_WIDGET(data->LV_arc));
 747         }
 748
 749 }
 750
 751 static void ui_arc_manage_update_post_split(GtkWidget *widget, gdouble amount)
 752 {
 753 struct ui_arc_manage_data *data;
 754 gboolean sensitive = TRUE;
 755
 756         DB( g_print("(ui_arc_manage) update _post_split\n") );
 757
 758         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 759
 760         DB( g_print("- amount=%.2f\n", amount) );
 761
 762         data->lastarcitem->amount = amount;
 763         gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_amount), amount);
 764
 765         data->lastarcitem->flags &= ~(OF_SPLIT); //First set flag that Splits are cleared
 766
 767         if (da_splits_length(data->lastarcitem->splits) > 0)
 768         {
 769         /* disable category if split is set */
 770                 data->lastarcitem->flags |= OF_SPLIT; //Then set flag that Splits are active
 771                 sensitive = FALSE;
 772                 ui_cat_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_grp), 0);
 773         }
 774         gtk_widget_set_sensitive(data->ST_amount, sensitive);
 775
 776         //# 1416624 empty category when split
 777         if( (data->lastarcitem->flags & (OF_SPLIT)) )
 778                 ui_cat_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_grp), 0);
 779         gtk_widget_set_sensitive(data->PO_grp, sensitive);
 780
 781 }
 782
 783
 784 //1336928 combobox tags
 785 static void ui_arc_manage_update_tags(GtkWidget *widget, gpointer user_data)
 786 {
 787 struct ui_arc_manage_data *data;
 788 gchar *newtag;
 789
 790         DB( g_print("\n[ui_scheduled] update tags\n") );
 791
 792         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 793
 794         newtag = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(data->CY_tags));
 795         ui_gtk_entry_tag_name_append(GTK_ENTRY(data->ST_tags), newtag);
 796         g_free(newtag);
 797
 798         //revert back to ----
 799         g_signal_handlers_block_by_func (G_OBJECT (data->CY_tags), G_CALLBACK (ui_arc_manage_update_tags), NULL);
 800         hbtk_combo_box_set_active_id(GTK_COMBO_BOX_TEXT(data->CY_tags), 0);
 801         g_signal_handlers_unblock_by_func (G_OBJECT (data->CY_tags), G_CALLBACK (ui_arc_manage_update_tags), NULL);
 802 }
 803
 804
 805 /*
 806 ** update the widgets status and contents from action/selection value
 807 */
 808 static void ui_arc_manage_update(GtkWidget *widget, gpointer user_data)
 809 {
 810 struct ui_arc_manage_data *data;
 811 GtkTreeModel             *model;
 812 GtkTreeIter                      iter;
 813 gboolean selected, sensitive;
 814 gboolean split_sensitive = TRUE;
 815 Archive *arcitem;
 816
 817
 818         DB( g_print("\n[ui_scheduled] update\n") );
 819
 820         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 821         //window = gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW);
 822         //DB( g_print("\n[ui_scheduled] widget=%08lx, window=%08lx, inst_data=%08lx\n", treeview, window, data) );
 823
 824         //if true there is a selected node
 825         selected = gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_arc)), &model, &iter);
 826
 827         DB( g_print(" selected = %d\n", selected) );
 828
 829         sensitive = (selected == TRUE) ? TRUE : FALSE;
 830
 831         gtk_widget_set_sensitive(data->GR_txnleft, sensitive);
 832         gtk_widget_set_sensitive(data->LB_schedinsert, sensitive);
 833
 834         gtk_widget_set_sensitive(data->CM_auto, sensitive);
 835
 836         gtk_widget_set_sensitive(data->BT_rem, sensitive);
 837
 838         if(selected)
 839         {
 840                 gtk_tree_model_get(model, &iter, LST_DEFARC_DATAS, &arcitem, -1);
 841
 842                 if(data->lastarcitem != NULL && arcitem != data->lastarcitem)
 843                 {
 844                         DB( g_print(" -> should do a get for last selected (%s)\n", data->lastarcitem->memo) );
 845                         ui_arc_manage_getlast(data);
 846                 }
 847                 data->lastarcitem = arcitem;
 848
 849                 if (da_splits_length(data->lastarcitem->splits) > 0)
 850                 {
 851
 852                         data->lastarcitem->flags |= OF_SPLIT; //Then set flag that Splits are active
 853                         split_sensitive = FALSE;
 854                         ui_cat_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_grp), 0);
 855                 }
 856
 857                 gtk_widget_set_sensitive(data->ST_amount, split_sensitive);
 858                 gtk_widget_set_sensitive(data->PO_grp, split_sensitive);
 859
 860                 DB( g_print(" - call set\n") );
 861                 ui_arc_manage_set(widget, NULL);
 862         }
 863         else
 864         {
 865                 data->lastarcitem = NULL;
 866         }
 867
 868         //gtk_widget_set_sensitive(data->LB_schedinsert, sensitive);
 869
 870
 871         DB( g_print(" - call scheduled\n") );
 872         ui_arc_manage_scheduled(widget, NULL);
 873         DB( g_print(" - call paymode\n") );
 874         ui_arc_manage_paymode(widget,NULL);
 875
 876
 877 }
 878
 879
 880
 881 /*
 882 **
 883 */
 884 static void ui_arc_manage_toggleamount(GtkWidget *widget, GtkEntryIconPosition icon_pos, GdkEvent *event, gpointer user_data)
 885 {
 886 struct ui_arc_manage_data *data;
 887 gdouble value;
 888
 889         DB( g_print("\n[ui_scheduled] toggleamount\n") );
 890
 891         if(icon_pos == GTK_ENTRY_ICON_PRIMARY)
 892         {
 893
 894                 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 895
 896                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->ST_amount));
 897
 898                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_amount));
 899                 value *= -1;
 900                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_amount), value);
 901
 902                 /*
 903                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_amount));
 904                 type = gtk_widget_get_sensitive(data->CY_amount);
 905
 906                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_amount), value * type);
 907                 */
 908         }
 909
 910 }
 911
 912
 913 static void defarchive_button_split_cb(GtkWidget *widget, gpointer user_data)
 914 {
 915 struct ui_arc_manage_data *data;
 916 gdouble amount;
 917
 918         DB( g_print("\n[ui_scheduled] doing split\n") );
 919
 920         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 921
 922         amount = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_amount));
 923
 924         ui_split_dialog(data->window, &data->lastarcitem->splits, amount, &ui_arc_manage_update_post_split);
 925
 926 }
 927
 928
 929 static void ui_arc_manage_selection(GtkTreeSelection *treeselection, gpointer user_data)
 930 {
 931         DB( g_print("\n[ui_scheduled] selection\n") );
 932
 933         DB( g_print(" - call update\n") );
 934         ui_arc_manage_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
 935 }
 936
 937
 938 static void ui_arc_manage_populate_listview(struct ui_arc_manage_data *data)
 939 {
 940 gint type;
 941
 942         DB( g_print("\n[ui_scheduled] populate listview\n") );
 943
 944         type = hbtk_radio_get_active(GTK_CONTAINER(data->RA_type)) == 1 ? ARC_TYPE_TEMPLATE : ARC_TYPE_SCHEDULED;
 945         ui_arc_listview_populate(data->LV_arc, type);
 946         gtk_tree_view_expand_all (GTK_TREE_VIEW(data->LV_arc));
 947 }
 948
 949
 950
 951
 952 static gboolean ui_arc_manage_cleanup(struct ui_arc_manage_data *data, gint result)
 953 {
 954 gboolean doupdate = FALSE;
 955
 956         DB( g_print("\n[ui_scheduled] cleanup\n") );
 957
 958
 959         if(data->lastarcitem != NULL)
 960         {
 961                 DB( g_print(" -> should do a get for last selected (%s)\n", data->lastarcitem->memo) );
 962                 ui_arc_manage_getlast(data);
 963         }
 964
 965         GLOBALS->arc_list = da_archive_sort(GLOBALS->arc_list);
 966
 967         GLOBALS->changes_count += data->change;
 968
 969         return doupdate;
 970 }
 971
 972 /*
 973 **
 974 */
 975 static void ui_arc_manage_setup(struct ui_arc_manage_data *data)
 976 {
 977
 978         DB( g_print("\n[ui_scheduled] setup\n") );
 979
 980         //init GList
 981         data->tmp_list = NULL; //hb-glist_clone_list(GLOBALS->arc_list, sizeof(struct _Archive));
 982         data->change = 0;
 983         data->lastarcitem = NULL;
 984
 985         //hb-glist_populate_treeview(data->tmp_list, data->LV_arc, LST_DEFARC_DATAS, LST_DEFARC_OLDPOS);
 986
 987         //insert all glist item into treeview
 988         ui_arc_manage_populate_listview(data);
 989
 990         DB( g_print(" - populate boxentries\n") );
 991
 992         ui_pay_comboboxentry_populate(GTK_COMBO_BOX(data->PO_pay)  , GLOBALS->h_pay);
 993         ui_cat_comboboxentry_populate(GTK_COMBO_BOX(data->PO_grp)  , GLOBALS->h_cat);
 994         ui_acc_comboboxentry_populate(GTK_COMBO_BOX(data->PO_acc)  , GLOBALS->h_acc, ACC_LST_INSERT_NORMAL);
 995         ui_acc_comboboxentry_populate(GTK_COMBO_BOX(data->PO_accto), GLOBALS->h_acc, ACC_LST_INSERT_NORMAL);
 996
 997         ui_tag_combobox_populate(GTK_COMBO_BOX_TEXT(data->CY_tags));
 998 }
 999
1000
1001 static GtkWidget *ui_arc_manage_create_left_txn(struct ui_arc_manage_data *data)
1002 {
1003 GtkWidget *group_grid, *hbox, *label, *widget;
1004 gint row;
1005
1006         // group :: Transaction detail
1007     group_grid = gtk_grid_new ();
1008     data->GR_txnleft = group_grid;
1009         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1010         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1011
1012         row = 0;
1013         label = make_label_widget(_("_Amount:"));
1014         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1015         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1016         gtk_grid_attach (GTK_GRID (group_grid), hbox, 1, row, 1, 1);
1017
1018                 widget = make_amount(label);
1019                 data->ST_amount = widget;
1020                 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget), GTK_ENTRY_ICON_PRIMARY, ICONNAME_HB_TOGGLE_SIGN);
1021                 gtk_entry_set_icon_tooltip_text(GTK_ENTRY(widget), GTK_ENTRY_ICON_PRIMARY, _("Toggle amount sign"));
1022                 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1023
1024                 widget = make_image_button(ICONNAME_HB_BUTTON_SPLIT, _("Transaction splits"));
1025                 data->BT_split = widget;
1026                 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1027
1028         row++;
1029         label = make_label_widget(_("A_ccount:"));
1030         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1031         widget = ui_acc_comboboxentry_new(label);
1032         data->PO_acc = widget;
1033         gtk_widget_set_hexpand (widget, TRUE);
1034         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1035
1036         row++;
1037         label = make_label_widget(_("_To account:"));
1038         data->LB_accto = label;
1039         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1040         widget = ui_acc_comboboxentry_new(label);
1041         data->PO_accto = widget;
1042         gtk_widget_set_hexpand (widget, TRUE);
1043         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1044
1045
1046         row++;
1047         label = make_label_widget(_("Pay_ment:"));
1048         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1049         widget = make_paymode(label);
1050         data->NU_mode = widget;
1051         gtk_widget_set_halign (widget, GTK_ALIGN_START);
1052         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1053
1054         gtk_widget_set_margin_top(label, SPACING_SMALL);
1055         gtk_widget_set_margin_top(widget, SPACING_SMALL);
1056
1057         gtk_widget_set_margin_bottom(label, SPACING_SMALL);
1058         gtk_widget_set_margin_bottom(widget, SPACING_SMALL);
1059
1060         row++;
1061         widget = gtk_check_button_new_with_mnemonic(_("Of notebook _2"));
1062         data->CM_cheque = widget;
1063         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1064
1065         /* info should be here some day */
1066
1067
1068
1069         row++;
1070         label = make_label_widget(_("_Payee:"));
1071         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1072         widget = ui_pay_comboboxentry_new(label);
1073         data->PO_pay = widget;
1074         gtk_widget_set_hexpand (widget, TRUE);
1075         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1076
1077         row++;
1078         label = make_label_widget(_("_Category:"));
1079         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1080         widget = ui_cat_comboboxentry_new(label);
1081         data->PO_grp = widget;
1082         gtk_widget_set_hexpand (widget, TRUE);
1083         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1084
1085         gtk_widget_set_margin_bottom(label, SPACING_SMALL);
1086         gtk_widget_set_margin_bottom(widget, SPACING_SMALL);
1087
1088         row++;
1089         label = make_label_widget(_("_Status:"));
1090         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1091         widget = hbtk_radio_new(CYA_TXN_STATUS, TRUE);
1092         data->RA_status = widget;
1093         gtk_widget_set_halign (widget, GTK_ALIGN_START);
1094         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1095
1096         row++;
1097         label = make_label_widget(_("_Memo:"));
1098         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1099         widget = make_string(label);
1100         gtk_widget_set_hexpand (widget, TRUE);
1101         data->ST_word = widget;
1102         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1103
1104         row++;
1105         label = make_label_widget(_("Ta_gs:"));
1106         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1107         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1108         gtk_grid_attach (GTK_GRID (group_grid), hbox, 1, row, 1, 1);
1109
1110                 widget = make_string(label);
1111                 data->ST_tags = widget;
1112                 //gtk_widget_set_hexpand (widget, TRUE);
1113                 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1114
1115                 widget = ui_tag_combobox_new(NULL);
1116                 data->CY_tags = widget;
1117                 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1118
1119         return group_grid;
1120 }
1121
1122
1123 static GtkWidget *ui_arc_manage_create_scheduling(struct ui_arc_manage_data *data)
1124 {
1125 GtkWidget *group_grid, *hbox, *label, *widget;
1126 gint row;
1127
1128         // group :: Scheduled insertion
1129         group_grid = gtk_grid_new ();
1130         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1131         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1132
1133         label = make_label_group(_("Scheduled insertion"));
1134         data->LB_schedinsert = label;
1135         gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
1136
1137         row = 1;
1138         widget = gtk_check_button_new_with_mnemonic(_("_Activate"));
1139         data->CM_auto = widget;
1140         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 2, 1);
1141
1142         row++;
1143         label = gtk_label_new_with_mnemonic (_("Next _date:"));
1144         data->LB_next = label;
1145         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1146         widget = gtk_date_entry_new();
1147         data->PO_next = widget;
1148         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1149
1150         row++;
1151         label = make_label_widget(_("Ever_y:"));
1152         data->LB_every = label;
1153         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1154
1155         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1156         gtk_grid_attach (GTK_GRID (group_grid), hbox, 2, row, 1, 1);
1157         widget = make_numeric(label, 1, 100);
1158         data->NB_every = widget;
1159     gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1160         //label = gtk_label_new_with_mnemonic (_("_Unit:"));
1161     //gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1162         widget = make_cycle(label, CYA_ARC_UNIT);
1163         data->CY_unit = widget;
1164     gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1165
1166         row++;
1167         label = make_label_widget(_("Week end:"));
1168         data->LB_weekend = label;
1169         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1170
1171         widget = hbtk_radio_new(RA_ARC_WEEKEND, FALSE);
1172         data->CY_weekend = widget;
1173         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1174
1175         row++;
1176         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1177         gtk_grid_attach (GTK_GRID (group_grid), hbox, 1, row, 3, 1);
1178
1179                 widget = gtk_check_button_new_with_mnemonic(_("_Stop after:"));
1180                 data->CM_limit = widget;
1181                 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1182
1183                 widget = make_numeric(label, 1, 366);
1184                 data->NB_limit = widget;
1185             gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1186
1187                 label = gtk_label_new_with_mnemonic (_("posts"));
1188                 data->LB_posts = label;
1189             gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1190
1191         return group_grid;
1192 }
1193
1194 static void ui_arc_manage_type_changed_cb (GtkToggleButton *button, gpointer user_data)
1195 {
1196         ui_arc_manage_populate_listview(user_data);
1197         //g_print(" toggle type=%d\n", gtk_toggle_button_get_active(button));
1198 }
1199
1200
1201 GtkWidget *ui_arc_manage_dialog (Archive *ext_arc)
1202 {
1203 struct ui_arc_manage_data data;
1204 GtkWidget *dialog, *content_area, *table, *bbox;
1205 GtkWidget *content_grid, *group_grid, *hgrid, *treeview, *scrollwin;
1206 GtkWidget *widget, *hpaned;
1207 gint w, h, row;
1208
1209         dialog = gtk_dialog_new_with_buttons (_("Manage scheduled/template transactions"),
1210                                             GTK_WINDOW(GLOBALS->mainwindow),
1211                                             0,
1212                                             _("_Close"),
1213                                             GTK_RESPONSE_ACCEPT,
1214                                             NULL);
1215
1216         data.window = dialog;
1217
1218         gtk_window_set_icon_name(GTK_WINDOW (dialog), ICONNAME_HB_ARCHIVE);
1219
1220         //set a nice dialog size
1221         gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
1222         gtk_window_set_default_size (GTK_WINDOW(dialog), -1, h/PHI);
1223
1224
1225         //store our dialog private data
1226         g_object_set_data(G_OBJECT(dialog), "inst_data", (gpointer)&data);
1227         DB( g_print("\n[ui_scheduled] dialog=%p, inst_data=%p\n", dialog, &data) );
1228
1229         //dialog content
1230         content_area = gtk_dialog_get_content_area(GTK_DIALOG (dialog));                // return a vbox
1231
1232    //our table
1233         table = gtk_grid_new ();
1234         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_MEDIUM);
1235         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
1236         g_object_set(table, "margin", SPACING_MEDIUM, NULL);
1237         gtk_box_pack_start (GTK_BOX (content_area), table, TRUE, TRUE, 0);
1238
1239         row = 0;
1240         bbox = hbtk_radio_new(RA_ARC_TYPE, TRUE);
1241         data.RA_type = bbox;
1242         gtk_widget_set_halign (bbox, GTK_ALIGN_CENTER);
1243         gtk_grid_attach (GTK_GRID (table), bbox, 0, row, 2, 1);
1244
1245         hbtk_radio_connect (GTK_CONTAINER(bbox), "toggled", G_CALLBACK (ui_arc_manage_type_changed_cb), &data);
1246
1247
1248         row++;
1249         hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
1250         //gtk_container_set_border_width (GTK_CONTAINER(hpaned), SPACING_MEDIUM);
1251         gtk_grid_attach (GTK_GRID (table), hpaned, 0, row, 2, 1);
1252
1253
1254         /* left area */
1255         hgrid = gtk_grid_new ();
1256         gtk_grid_set_row_spacing (GTK_GRID (hgrid), SPACING_SMALL);
1257         gtk_grid_set_column_spacing (GTK_GRID (hgrid), SPACING_MEDIUM);
1258         gtk_widget_set_margin_right(hgrid, SPACING_SMALL);
1259         gtk_paned_pack1 (GTK_PANED(hpaned), hgrid, FALSE, FALSE);
1260
1261         // listview
1262         scrollwin = gtk_scrolled_window_new(NULL,NULL);
1263     gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1264         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1265         treeview = (GtkWidget *)ui_arc_listview_new();
1266         data.LV_arc = treeview;
1267         gtk_widget_set_size_request(treeview, HB_MINWIDTH_LIST, -1);
1268         gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
1269         gtk_widget_set_hexpand (scrollwin, TRUE);
1270         gtk_widget_set_vexpand (scrollwin, TRUE);
1271         gtk_grid_attach (GTK_GRID (hgrid), scrollwin, 0, 0, 2, 1);
1272
1273         widget = gtk_button_new_with_mnemonic(_("_Add"));
1274         data.BT_add = widget;
1275         gtk_grid_attach (GTK_GRID (hgrid), widget, 0, 1, 1, 1);
1276
1277         widget = gtk_button_new_with_mnemonic(_("_Delete"));
1278         data.BT_rem = widget;
1279         gtk_grid_attach (GTK_GRID (hgrid), widget, 1, 1, 1, 1);
1280
1281
1282         /* right area */
1283         content_grid = gtk_grid_new();
1284         gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
1285         gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
1286         //gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
1287         gtk_widget_set_margin_left(content_grid, SPACING_SMALL);
1288         gtk_paned_pack2 (GTK_PANED(hpaned), content_grid, FALSE, FALSE);
1289
1290         group_grid = ui_arc_manage_create_left_txn(&data);
1291         //gtk_widget_set_hexpand (GTK_WIDGET(group_grid), FALSE);
1292         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 0, 1, 1);
1293
1294         /* sheduling */
1295         group_grid = ui_arc_manage_create_scheduling(&data);
1296         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 1, 1, 1);
1297
1298         /* set default periodicity to month */
1299         //todo: move elsewhere
1300         gtk_combo_box_set_active(GTK_COMBO_BOX(data.CY_unit), 2);
1301
1302         gtk_widget_show_all(content_area);
1303         gtk_widget_hide(data.CM_cheque);
1304         gtk_widget_hide(data.PO_accto);
1305
1306         //connect all our signals
1307         g_signal_connect (dialog, "destroy", G_CALLBACK (gtk_widget_destroyed), &dialog);
1308
1309
1310         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data.LV_arc)), "changed", G_CALLBACK (ui_arc_manage_selection), NULL);
1311         g_signal_connect (G_OBJECT (data.ST_amount), "icon-release", G_CALLBACK (ui_arc_manage_toggleamount), NULL);
1312
1313         g_signal_connect (G_OBJECT (data.BT_add), "clicked", G_CALLBACK (ui_arc_manage_add), NULL);
1314         g_signal_connect (G_OBJECT (data.BT_rem), "clicked", G_CALLBACK (ui_arc_manage_delete), NULL);
1315
1316         data.handler_id[HID_ARC_MEMO] = g_signal_connect (G_OBJECT (data.ST_word), "changed", G_CALLBACK (ui_arc_manage_rename), NULL);
1317         g_signal_connect (data.NU_mode, "changed", G_CALLBACK (ui_arc_manage_paymode), NULL);
1318         g_signal_connect (data.PO_acc, "changed", G_CALLBACK (ui_arc_manage_update_accto), NULL);
1319         //data.handler_id[HID_ARC_VALID]  = g_signal_connect (data.CM_valid , "toggled", G_CALLBACK (ui_arc_manage_togglestatus), GINT_TO_POINTER(HID_ARC_VALID));
1320         //data.handler_id[HID_ARC_REMIND] = g_signal_connect (data.CM_remind, "toggled", G_CALLBACK (ui_arc_manage_togglestatus), GINT_TO_POINTER(HID_ARC_REMIND));
1321
1322         g_signal_connect (data.CY_tags , "changed", G_CALLBACK (ui_arc_manage_update_tags), NULL);
1323
1324         g_signal_connect (data.CM_auto, "toggled", G_CALLBACK (ui_arc_manage_scheduled), NULL);
1325         g_signal_connect (data.CM_limit, "toggled", G_CALLBACK (ui_arc_manage_scheduled), NULL);
1326
1327         g_signal_connect (G_OBJECT (data.BT_split), "clicked", G_CALLBACK (defarchive_button_split_cb), NULL);
1328
1329         //setup, init and show dialog
1330         ui_arc_manage_setup(&data);
1331         ui_arc_manage_update(data.LV_arc, NULL);
1332
1333         gtk_widget_show (dialog);
1334
1335         if(ext_arc != NULL)
1336                 ui_arc_listview_select_by_pointer(GTK_TREE_VIEW(data.LV_arc), ext_arc);
1337
1338         //wait for the user
1339         gint result = gtk_dialog_run (GTK_DIALOG (dialog));
1340
1341         switch (result)
1342     {
1343         case GTK_RESPONSE_ACCEPT:
1344            //do_application_specific_something ();
1345            break;
1346         default:
1347            //do_nothing_since_dialog_was_cancelled ();
1348            break;
1349     }
1350
1351         // cleanup and destroy
1352         ui_arc_manage_cleanup(&data, result);
1353         gtk_widget_destroy (dialog);
1354
1355         return NULL;
1356 }
1357
1358