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_button_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_button_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_button_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_button_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_button_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 /*
 785 ** update the widgets status and contents from action/selection value
 786 */
 787 static void ui_arc_manage_update(GtkWidget *widget, gpointer user_data)
 788 {
 789 struct ui_arc_manage_data *data;
 790 GtkTreeModel             *model;
 791 GtkTreeIter                      iter;
 792 gboolean selected, sensitive;
 793 gboolean split_sensitive = TRUE;
 794 Archive *arcitem;
 795
 796
 797         DB( g_print("\n[ui_scheduled] update\n") );
 798
 799         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 800         //window = gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW);
 801         //DB( g_print("\n[ui_scheduled] widget=%08lx, window=%08lx, inst_data=%08lx\n", treeview, window, data) );
 802
 803         //if true there is a selected node
 804         selected = gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_arc)), &model, &iter);
 805
 806         DB( g_print(" selected = %d\n", selected) );
 807
 808         sensitive = (selected == TRUE) ? TRUE : FALSE;
 809
 810         gtk_widget_set_sensitive(data->GR_txnleft, sensitive);
 811         gtk_widget_set_sensitive(data->LB_schedinsert, sensitive);
 812
 813         gtk_widget_set_sensitive(data->CM_auto, sensitive);
 814
 815         gtk_widget_set_sensitive(data->BT_rem, sensitive);
 816
 817         if(selected)
 818         {
 819                 gtk_tree_model_get(model, &iter, LST_DEFARC_DATAS, &arcitem, -1);
 820
 821                 if(data->lastarcitem != NULL && arcitem != data->lastarcitem)
 822                 {
 823                         DB( g_print(" -> should do a get for last selected (%s)\n", data->lastarcitem->memo) );
 824                         ui_arc_manage_getlast(data);
 825                 }
 826                 data->lastarcitem = arcitem;
 827
 828                 if (da_splits_length(data->lastarcitem->splits) > 0)
 829                 {
 830
 831                         data->lastarcitem->flags |= OF_SPLIT; //Then set flag that Splits are active
 832                         split_sensitive = FALSE;
 833                         ui_cat_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_grp), 0);
 834                 }
 835
 836                 gtk_widget_set_sensitive(data->ST_amount, split_sensitive);
 837                 gtk_widget_set_sensitive(data->PO_grp, split_sensitive);
 838
 839                 DB( g_print(" - call set\n") );
 840                 ui_arc_manage_set(widget, NULL);
 841         }
 842         else
 843         {
 844                 data->lastarcitem = NULL;
 845         }
 846
 847         //gtk_widget_set_sensitive(data->LB_schedinsert, sensitive);
 848
 849
 850         DB( g_print(" - call scheduled\n") );
 851         ui_arc_manage_scheduled(widget, NULL);
 852         DB( g_print(" - call paymode\n") );
 853         ui_arc_manage_paymode(widget,NULL);
 854
 855
 856 }
 857
 858
 859
 860 /*
 861 **
 862 */
 863 static void ui_arc_manage_toggleamount(GtkWidget *widget, GtkEntryIconPosition icon_pos, GdkEvent *event, gpointer user_data)
 864 {
 865 struct ui_arc_manage_data *data;
 866 gdouble value;
 867
 868         DB( g_print("\n[ui_scheduled] toggleamount\n") );
 869
 870         if(icon_pos == GTK_ENTRY_ICON_PRIMARY)
 871         {
 872
 873                 data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 874
 875                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->ST_amount));
 876
 877                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_amount));
 878                 value *= -1;
 879                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_amount), value);
 880
 881                 /*
 882                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_amount));
 883                 type = gtk_widget_get_sensitive(data->CY_amount);
 884
 885                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_amount), value * type);
 886                 */
 887         }
 888
 889 }
 890
 891
 892 static void defarchive_button_split_cb(GtkWidget *widget, gpointer user_data)
 893 {
 894 struct ui_arc_manage_data *data;
 895 gdouble amount;
 896
 897         DB( g_print("\n[ui_scheduled] doing split\n") );
 898
 899         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 900
 901         amount = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_amount));
 902
 903         ui_split_dialog(data->window, &data->lastarcitem->splits, amount, &ui_arc_manage_update_post_split);
 904
 905 }
 906
 907
 908 static void ui_arc_manage_selection(GtkTreeSelection *treeselection, gpointer user_data)
 909 {
 910         DB( g_print("\n[ui_scheduled] selection\n") );
 911
 912         DB( g_print(" - call update\n") );
 913         ui_arc_manage_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
 914 }
 915
 916
 917 static void ui_arc_manage_populate_listview(struct ui_arc_manage_data *data)
 918 {
 919 gint type;
 920
 921         DB( g_print("\n[ui_scheduled] populate listview\n") );
 922
 923         type = hbtk_radio_button_get_active(GTK_CONTAINER(data->RA_type)) == 1 ? ARC_TYPE_TEMPLATE : ARC_TYPE_SCHEDULED;
 924         ui_arc_listview_populate(data->LV_arc, type);
 925         gtk_tree_view_expand_all (GTK_TREE_VIEW(data->LV_arc));
 926 }
 927
 928
 929
 930
 931 static gboolean ui_arc_manage_cleanup(struct ui_arc_manage_data *data, gint result)
 932 {
 933 gboolean doupdate = FALSE;
 934
 935         DB( g_print("\n[ui_scheduled] cleanup\n") );
 936
 937
 938         if(data->lastarcitem != NULL)
 939         {
 940                 DB( g_print(" -> should do a get for last selected (%s)\n", data->lastarcitem->memo) );
 941                 ui_arc_manage_getlast(data);
 942         }
 943
 944         GLOBALS->arc_list = da_archive_sort(GLOBALS->arc_list);
 945
 946         GLOBALS->changes_count += data->change;
 947
 948         return doupdate;
 949 }
 950
 951 /*
 952 **
 953 */
 954 static void ui_arc_manage_setup(struct ui_arc_manage_data *data)
 955 {
 956
 957         DB( g_print("\n[ui_scheduled] setup\n") );
 958
 959         //init GList
 960         data->tmp_list = NULL; //hb-glist_clone_list(GLOBALS->arc_list, sizeof(struct _Archive));
 961         data->change = 0;
 962         data->lastarcitem = NULL;
 963
 964         //hb-glist_populate_treeview(data->tmp_list, data->LV_arc, LST_DEFARC_DATAS, LST_DEFARC_OLDPOS);
 965
 966         //insert all glist item into treeview
 967         ui_arc_manage_populate_listview(data);
 968
 969         DB( g_print(" - populate boxentries\n") );
 970
 971         ui_pay_comboboxentry_populate(GTK_COMBO_BOX(data->PO_pay)  , GLOBALS->h_pay);
 972         ui_cat_comboboxentry_populate(GTK_COMBO_BOX(data->PO_grp)  , GLOBALS->h_cat);
 973         ui_acc_comboboxentry_populate(GTK_COMBO_BOX(data->PO_acc)  , GLOBALS->h_acc, ACC_LST_INSERT_NORMAL);
 974         ui_acc_comboboxentry_populate(GTK_COMBO_BOX(data->PO_accto), GLOBALS->h_acc, ACC_LST_INSERT_NORMAL);
 975
 976         ////5.2.7 done in popover
 977         //ui_tag_combobox_populate(GTK_COMBO_BOX_TEXT(data->CY_tags));
 978 }
 979
 980
 981 static GtkWidget *ui_arc_manage_create_left_txn(struct ui_arc_manage_data *data)
 982 {
 983 GtkWidget *group_grid, *hbox, *label, *widget;
 984 gint row;
 985
 986         // group :: Transaction detail
 987     group_grid = gtk_grid_new ();
 988     data->GR_txnleft = group_grid;
 989         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 990         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 991
 992         row = 0;
 993         label = make_label_widget(_("_Amount:"));
 994         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
 995         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 996         gtk_grid_attach (GTK_GRID (group_grid), hbox, 1, row, 1, 1);
 997
 998                 widget = make_amount(label);
 999                 data->ST_amount = widget;
1000                 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget), GTK_ENTRY_ICON_PRIMARY, ICONNAME_HB_TOGGLE_SIGN);
1001                 gtk_entry_set_icon_tooltip_text(GTK_ENTRY(widget), GTK_ENTRY_ICON_PRIMARY, _("Toggle amount sign"));
1002                 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1003
1004                 widget = make_image_button(ICONNAME_HB_BUTTON_SPLIT, _("Transaction splits"));
1005                 data->BT_split = widget;
1006                 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1007
1008         row++;
1009         label = make_label_widget(_("A_ccount:"));
1010         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1011         widget = ui_acc_comboboxentry_new(label);
1012         data->PO_acc = widget;
1013         gtk_widget_set_hexpand (widget, TRUE);
1014         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1015
1016         row++;
1017         label = make_label_widget(_("_To account:"));
1018         data->LB_accto = label;
1019         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1020         widget = ui_acc_comboboxentry_new(label);
1021         data->PO_accto = widget;
1022         gtk_widget_set_hexpand (widget, TRUE);
1023         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1024
1025
1026         row++;
1027         label = make_label_widget(_("Pay_ment:"));
1028         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1029         widget = make_paymode(label);
1030         data->NU_mode = widget;
1031         gtk_widget_set_halign (widget, GTK_ALIGN_START);
1032         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1033
1034         gtk_widget_set_margin_top(label, SPACING_SMALL);
1035         gtk_widget_set_margin_top(widget, SPACING_SMALL);
1036
1037         gtk_widget_set_margin_bottom(label, SPACING_SMALL);
1038         gtk_widget_set_margin_bottom(widget, SPACING_SMALL);
1039
1040         row++;
1041         widget = gtk_check_button_new_with_mnemonic(_("Of notebook _2"));
1042         data->CM_cheque = widget;
1043         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1044
1045         /* info should be here some day */
1046
1047
1048
1049         row++;
1050         label = make_label_widget(_("_Payee:"));
1051         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1052         widget = ui_pay_comboboxentry_new(label);
1053         data->PO_pay = widget;
1054         gtk_widget_set_hexpand (widget, TRUE);
1055         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1056
1057         row++;
1058         label = make_label_widget(_("_Category:"));
1059         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1060         widget = ui_cat_comboboxentry_new(label);
1061         data->PO_grp = widget;
1062         gtk_widget_set_hexpand (widget, TRUE);
1063         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1064
1065         gtk_widget_set_margin_bottom(label, SPACING_SMALL);
1066         gtk_widget_set_margin_bottom(widget, SPACING_SMALL);
1067
1068         row++;
1069         label = make_label_widget(_("_Status:"));
1070         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1071         widget = hbtk_radio_button_new(CYA_TXN_STATUS, TRUE);
1072         data->RA_status = widget;
1073         gtk_widget_set_halign (widget, GTK_ALIGN_START);
1074         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1075
1076         row++;
1077         label = make_label_widget(_("_Memo:"));
1078         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1079         widget = make_string(label);
1080         gtk_widget_set_hexpand (widget, TRUE);
1081         data->ST_word = widget;
1082         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1083
1084         row++;
1085         label = make_label_widget(_("Ta_gs:"));
1086         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
1087         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1088         gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET(hbox)), GTK_STYLE_CLASS_LINKED);
1089         gtk_grid_attach (GTK_GRID (group_grid), hbox, 1, row, 1, 1);
1090
1091                 widget = make_string(label);
1092                 data->ST_tags = widget;
1093                 //gtk_widget_set_hexpand (widget, TRUE);
1094                 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1095
1096                 widget = ui_tag_popover_list(data->ST_tags);
1097                 data->CY_tags = widget;
1098                 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1099
1100         return group_grid;
1101 }
1102
1103
1104 static GtkWidget *ui_arc_manage_create_scheduling(struct ui_arc_manage_data *data)
1105 {
1106 GtkWidget *group_grid, *hbox, *label, *widget;
1107 gint row;
1108
1109         // group :: Scheduled insertion
1110         group_grid = gtk_grid_new ();
1111         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1112         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1113
1114         label = make_label_group(_("Scheduled insertion"));
1115         data->LB_schedinsert = label;
1116         gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
1117
1118         row = 1;
1119         widget = gtk_check_button_new_with_mnemonic(_("_Activate"));
1120         data->CM_auto = widget;
1121         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 2, 1);
1122
1123         row++;
1124         label = gtk_label_new_with_mnemonic (_("Next _date:"));
1125         data->LB_next = label;
1126         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1127         widget = gtk_date_entry_new();
1128         data->PO_next = widget;
1129         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1130
1131         row++;
1132         label = make_label_widget(_("Ever_y:"));
1133         data->LB_every = label;
1134         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1135
1136         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1137         gtk_grid_attach (GTK_GRID (group_grid), hbox, 2, row, 1, 1);
1138         widget = make_numeric(label, 1, 100);
1139         data->NB_every = widget;
1140     gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1141         //label = gtk_label_new_with_mnemonic (_("_Unit:"));
1142     //gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1143         widget = make_cycle(label, CYA_ARC_UNIT);
1144         data->CY_unit = widget;
1145     gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1146
1147         row++;
1148         label = make_label_widget(_("Week end:"));
1149         data->LB_weekend = label;
1150         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1151
1152         widget = hbtk_radio_button_new(RA_ARC_WEEKEND, FALSE);
1153         data->CY_weekend = widget;
1154         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1155
1156         row++;
1157         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1158         gtk_grid_attach (GTK_GRID (group_grid), hbox, 1, row, 3, 1);
1159
1160                 widget = gtk_check_button_new_with_mnemonic(_("_Stop after:"));
1161                 data->CM_limit = widget;
1162                 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1163
1164                 widget = make_numeric(label, 1, 366);
1165                 data->NB_limit = widget;
1166             gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1167
1168                 label = gtk_label_new_with_mnemonic (_("posts"));
1169                 data->LB_posts = label;
1170             gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1171
1172         return group_grid;
1173 }
1174
1175 static void ui_arc_manage_type_changed_cb (GtkToggleButton *button, gpointer user_data)
1176 {
1177         ui_arc_manage_populate_listview(user_data);
1178         //g_print(" toggle type=%d\n", gtk_toggle_button_get_active(button));
1179 }
1180
1181
1182 GtkWidget *ui_arc_manage_dialog (Archive *ext_arc)
1183 {
1184 struct ui_arc_manage_data data;
1185 GtkWidget *dialog, *content_area, *table, *bbox;
1186 GtkWidget *content_grid, *group_grid, *hgrid, *treeview, *scrollwin;
1187 GtkWidget *widget, *hpaned;
1188 gint w, h, row;
1189
1190         dialog = gtk_dialog_new_with_buttons (_("Manage scheduled/template transactions"),
1191                                             GTK_WINDOW(GLOBALS->mainwindow),
1192                                             0,
1193                                             _("_Close"),
1194                                             GTK_RESPONSE_ACCEPT,
1195                                             NULL);
1196
1197         data.window = dialog;
1198
1199         gtk_window_set_icon_name(GTK_WINDOW (dialog), ICONNAME_HB_ARCHIVE);
1200
1201         //set a nice dialog size
1202         gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
1203         gtk_window_set_default_size (GTK_WINDOW(dialog), -1, h/PHI);
1204
1205
1206         //store our dialog private data
1207         g_object_set_data(G_OBJECT(dialog), "inst_data", (gpointer)&data);
1208         DB( g_print("\n[ui_scheduled] dialog=%p, inst_data=%p\n", dialog, &data) );
1209
1210         //dialog content
1211         content_area = gtk_dialog_get_content_area(GTK_DIALOG (dialog));                // return a vbox
1212
1213    //our table
1214         table = gtk_grid_new ();
1215         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_MEDIUM);
1216         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
1217         g_object_set(table, "margin", SPACING_MEDIUM, NULL);
1218         gtk_box_pack_start (GTK_BOX (content_area), table, TRUE, TRUE, 0);
1219
1220         row = 0;
1221         bbox = hbtk_radio_button_new(RA_ARC_TYPE, TRUE);
1222         data.RA_type = bbox;
1223         gtk_widget_set_halign (bbox, GTK_ALIGN_CENTER);
1224         gtk_grid_attach (GTK_GRID (table), bbox, 0, row, 2, 1);
1225
1226         hbtk_radio_button_connect (GTK_CONTAINER(bbox), "toggled", G_CALLBACK (ui_arc_manage_type_changed_cb), &data);
1227
1228
1229         row++;
1230         hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
1231         //gtk_container_set_border_width (GTK_CONTAINER(hpaned), SPACING_MEDIUM);
1232         gtk_grid_attach (GTK_GRID (table), hpaned, 0, row, 2, 1);
1233
1234
1235         /* left area */
1236         hgrid = gtk_grid_new ();
1237         gtk_grid_set_row_spacing (GTK_GRID (hgrid), SPACING_SMALL);
1238         gtk_grid_set_column_spacing (GTK_GRID (hgrid), SPACING_SMALL);
1239         gtk_widget_set_margin_right(hgrid, SPACING_SMALL);
1240         gtk_paned_pack1 (GTK_PANED(hpaned), hgrid, FALSE, FALSE);
1241
1242         // listview
1243         scrollwin = gtk_scrolled_window_new(NULL,NULL);
1244     gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1245         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1246         treeview = (GtkWidget *)ui_arc_listview_new();
1247         data.LV_arc = treeview;
1248         gtk_widget_set_size_request(treeview, HB_MINWIDTH_LIST, -1);
1249         gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
1250         gtk_widget_set_hexpand (scrollwin, TRUE);
1251         gtk_widget_set_vexpand (scrollwin, TRUE);
1252         gtk_grid_attach (GTK_GRID (hgrid), scrollwin, 0, 0, 2, 1);
1253
1254         widget = gtk_button_new_with_mnemonic(_("_Add"));
1255         data.BT_add = widget;
1256         gtk_grid_attach (GTK_GRID (hgrid), widget, 0, 1, 1, 1);
1257
1258         widget = gtk_button_new_with_mnemonic(_("_Delete"));
1259         data.BT_rem = widget;
1260         gtk_grid_attach (GTK_GRID (hgrid), widget, 1, 1, 1, 1);
1261
1262
1263         /* right area */
1264         content_grid = gtk_grid_new();
1265         gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
1266         gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
1267         //gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
1268         gtk_widget_set_margin_left(content_grid, SPACING_SMALL);
1269         gtk_paned_pack2 (GTK_PANED(hpaned), content_grid, FALSE, FALSE);
1270
1271         group_grid = ui_arc_manage_create_left_txn(&data);
1272         //gtk_widget_set_hexpand (GTK_WIDGET(group_grid), FALSE);
1273         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 0, 1, 1);
1274
1275         /* sheduling */
1276         group_grid = ui_arc_manage_create_scheduling(&data);
1277         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 1, 1, 1);
1278
1279         /* set default periodicity to month */
1280         //todo: move elsewhere
1281         gtk_combo_box_set_active(GTK_COMBO_BOX(data.CY_unit), 2);
1282
1283         gtk_widget_show_all(content_area);
1284         gtk_widget_hide(data.CM_cheque);
1285         gtk_widget_hide(data.PO_accto);
1286
1287         //connect all our signals
1288         g_signal_connect (dialog, "destroy", G_CALLBACK (gtk_widget_destroyed), &dialog);
1289
1290
1291         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data.LV_arc)), "changed", G_CALLBACK (ui_arc_manage_selection), NULL);
1292         g_signal_connect (G_OBJECT (data.ST_amount), "icon-release", G_CALLBACK (ui_arc_manage_toggleamount), NULL);
1293
1294         g_signal_connect (G_OBJECT (data.BT_add), "clicked", G_CALLBACK (ui_arc_manage_add), NULL);
1295         g_signal_connect (G_OBJECT (data.BT_rem), "clicked", G_CALLBACK (ui_arc_manage_delete), NULL);
1296
1297         data.handler_id[HID_ARC_MEMO] = g_signal_connect (G_OBJECT (data.ST_word), "changed", G_CALLBACK (ui_arc_manage_rename), NULL);
1298         g_signal_connect (data.NU_mode, "changed", G_CALLBACK (ui_arc_manage_paymode), NULL);
1299         g_signal_connect (data.PO_acc, "changed", G_CALLBACK (ui_arc_manage_update_accto), NULL);
1300         //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));
1301         //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));
1302
1303         g_signal_connect (data.CM_auto, "toggled", G_CALLBACK (ui_arc_manage_scheduled), NULL);
1304         g_signal_connect (data.CM_limit, "toggled", G_CALLBACK (ui_arc_manage_scheduled), NULL);
1305
1306         g_signal_connect (G_OBJECT (data.BT_split), "clicked", G_CALLBACK (defarchive_button_split_cb), NULL);
1307
1308         //setup, init and show dialog
1309         ui_arc_manage_setup(&data);
1310         ui_arc_manage_update(data.LV_arc, NULL);
1311
1312         gtk_widget_show (dialog);
1313
1314         if(ext_arc != NULL)
1315                 ui_arc_listview_select_by_pointer(GTK_TREE_VIEW(data.LV_arc), ext_arc);
1316
1317         //wait for the user
1318         gint result = gtk_dialog_run (GTK_DIALOG (dialog));
1319
1320         switch (result)
1321     {
1322         case GTK_RESPONSE_ACCEPT:
1323            //do_application_specific_something ();
1324            break;
1325         default:
1326            //do_nothing_since_dialog_was_cancelled ();
1327            break;
1328     }
1329
1330         // cleanup and destroy
1331         ui_arc_manage_cleanup(&data, result);
1332         gtk_widget_destroy (dialog);
1333
1334         return NULL;
1335 }
1336
1337