Dogcows Code - chaz/homebank/blob - src/ui-account.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 #include "homebank.h"
  21 #include "hb-account.h"
  22 #include "ui-account.h"
  23 #include "ui-currency.h"
  24
  25 #define MYDEBUG 0
  26
  27 #if MYDEBUG
  28 #define DB(x) (x);
  29 #else
  30 #define DB(x);
  31 #endif
  32
  33 /* our global datas */
  34 extern struct HomeBank *GLOBALS;
  35 extern struct Preferences *PREFS;
  36
  37
  38 extern HbKvData CYA_ACC_TYPE[];
  39
  40
  41 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  42
  43
  44
  45
  46
  47
  48 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  49
  50
  51 /**
  52  * ui_acc_comboboxentry_get_key:
  53  *
  54  * get the key of the active account
  55  * and create the account if it do not exists
  56  *
  57  * Return value: the key or 0
  58  *
  59  */
  60 guint32
  61 ui_acc_comboboxentry_get_key(GtkComboBox *entry_box)
  62 {
  63 gchar *name;
  64 Account *item;
  65
  66         name = (gchar *)gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))));
  67         item = da_acc_get_by_name(name);
  68
  69         if( item == NULL )
  70         {
  71                 //todo: future : ask the user here
  72                 return 0;
  73         }
  74
  75         return item->key;
  76 }
  77
  78
  79 gboolean
  80 ui_acc_comboboxentry_set_active(GtkComboBox *entry_box, guint32 key)
  81 {
  82 Account *item;
  83
  84         if( key > 0 )
  85         {
  86                 item = da_acc_get(key);
  87                 if( (item != NULL) )
  88                 {
  89                         gtk_entry_set_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))), item->name);
  90                         return TRUE;
  91                 }
  92         }
  93         gtk_entry_set_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))), "");
  94         return FALSE;
  95 }
  96
  97
  98 /**
  99  * ui_acc_comboboxentry_add:
 100  *
 101  * Add a single element (useful for dynamics add)
 102  *
 103  * Return value: --
 104  *
 105  */
 106 void
 107 ui_acc_comboboxentry_add(GtkComboBox *entry_box, Account *acc)
 108 {
 109         if( acc->name != NULL )
 110         {
 111         GtkTreeModel *model;
 112         GtkTreeIter  iter;
 113
 114                 model = gtk_combo_box_get_model(GTK_COMBO_BOX(entry_box));
 115
 116                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 117                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 118                         0, acc->name,
 119                         1, acc->pos,
 120                         -1);
 121         }
 122 }
 123
 124
 125 static void
 126 ui_acc_comboboxentry_populate_ghfunc(gpointer key, gpointer value, struct accPopContext *ctx)
 127 {
 128 GtkTreeIter  iter;
 129 Account *acc = value;
 130
 131         if( (acc->flags & AF_CLOSED) ) return;
 132         if( (ctx->insert_type == ACC_LST_INSERT_REPORT) && (acc->flags & AF_NOREPORT) ) return;
 133         if( (acc->key == ctx->except_key) ) return;
 134
 135         //todo check this
 136         if( (ctx->kcur > 0 ) && (acc->kcur != ctx->kcur) ) return;
 137
 138     DB( g_print (" -> append %s\n", acc->name) );
 139
 140
 141         gtk_list_store_append (GTK_LIST_STORE(ctx->model), &iter);
 142         gtk_list_store_set (GTK_LIST_STORE(ctx->model), &iter,
 143                         0, acc->name,
 144                         1, acc->pos,
 145                         -1);
 146 }
 147
 148 /**
 149  * ui_acc_comboboxentry_populate:
 150  *
 151  * Populate the list and completion
 152  *
 153  * Return value: --
 154  *
 155  */
 156 void
 157 ui_acc_comboboxentry_populate(GtkComboBox *entry_box, GHashTable *hash, gint insert_type)
 158 {
 159         ui_acc_comboboxentry_populate_except(entry_box, hash, 0, insert_type);
 160 }
 161
 162 void
 163 ui_acc_comboboxentry_populate_except(GtkComboBox *entry_box, GHashTable *hash, guint except_key, gint insert_type)
 164 {
 165 GtkTreeModel *model;
 166 GtkEntryCompletion *completion;
 167 struct accPopContext ctx;
 168
 169     DB( g_print ("ui_acc_comboboxentry_populate\n") );
 170
 171     DB( g_print (" -> except is %d\n", except_key) );
 172
 173         model = gtk_combo_box_get_model(GTK_COMBO_BOX(entry_box));
 174         completion = gtk_entry_get_completion(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))));
 175
 176         /* keep our model alive and detach from comboboxentry and completion */
 177         g_object_ref(model);
 178         gtk_combo_box_set_model(GTK_COMBO_BOX(entry_box), NULL);
 179         gtk_entry_completion_set_model (completion, NULL);
 180
 181         /* clear and populate */
 182         ctx.model = model;
 183         ctx.except_key = except_key;
 184         ctx.kcur = 0;
 185         ctx.insert_type = insert_type;
 186         Account *acc = da_acc_get(except_key);
 187         if(acc != NULL)
 188                 ctx.kcur = acc->kcur;
 189
 190         gtk_list_store_clear (GTK_LIST_STORE(model));
 191         g_hash_table_foreach(hash, (GHFunc)ui_acc_comboboxentry_populate_ghfunc, &ctx);
 192
 193         /* reatach our model */
 194         gtk_combo_box_set_model(GTK_COMBO_BOX(entry_box), model);
 195         gtk_entry_completion_set_model (completion, model);
 196         g_object_unref(model);
 197
 198         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 199
 200
 201 }
 202
 203
 204 static gint
 205 ui_acc_comboboxentry_compare_func (GtkTreeModel *model, GtkTreeIter  *a, GtkTreeIter  *b, gpointer      userdata)
 206 {
 207 gint pos1, pos2;
 208
 209     gtk_tree_model_get(model, a, 1, &pos1, -1);
 210     gtk_tree_model_get(model, b, 1, &pos2, -1);
 211         return (pos1 - pos2);
 212 }
 213
 214
 215 /**
 216  * ui_acc_comboboxentry_new:
 217  *
 218  * Create a new account comboboxentry
 219  *
 220  * Return value: the new widget
 221  *
 222  */
 223 GtkWidget *
 224 ui_acc_comboboxentry_new(GtkWidget *label)
 225 {
 226 GtkListStore *store;
 227 GtkWidget *comboboxentry;
 228 GtkEntryCompletion *completion;
 229
 230         store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 231         gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), ui_acc_comboboxentry_compare_func, NULL, NULL);
 232         //gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 233
 234     completion = gtk_entry_completion_new ();
 235     gtk_entry_completion_set_model (completion, GTK_TREE_MODEL(store));
 236     gtk_entry_completion_set_text_column (completion, 0);
 237
 238 /*      renderer = gtk_cell_renderer_text_new ();
 239         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (completion), renderer, TRUE);
 240         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (completion), renderer, "text", 0, NULL);
 241 */
 242
 243         comboboxentry = gtk_combo_box_new_with_model_and_entry(GTK_TREE_MODEL(store));
 244         gtk_entry_set_completion (GTK_ENTRY (gtk_bin_get_child(GTK_BIN (comboboxentry))), completion);
 245         gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(comboboxentry), 0);
 246
 247 /*      gtk_cell_layout_clear(GTK_CELL_LAYOUT (comboboxentry));
 248
 249         renderer = gtk_cell_renderer_text_new ();
 250         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (comboboxentry), renderer, TRUE);
 251         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (comboboxentry), renderer, "text", 0, NULL);
 252 */
 253         g_object_unref(store);
 254
 255         if(label)
 256                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), comboboxentry);
 257
 258         gtk_widget_set_size_request(comboboxentry, HB_MINWIDTH_LIST, -1);
 259
 260         return comboboxentry;
 261 }
 262
 263 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 264
 265
 266 static void
 267 ui_acc_listview_toggled_cb (GtkCellRendererToggle *cell,
 268                gchar                 *path_str,
 269                gpointer               data)
 270 {
 271   GtkTreeModel *model = (GtkTreeModel *)data;
 272   GtkTreeIter  iter;
 273   GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
 274   gboolean fixed;
 275
 276   /* get toggled iter */
 277   gtk_tree_model_get_iter (model, &iter, path);
 278   gtk_tree_model_get (model, &iter, LST_DEFACC_TOGGLE, &fixed, -1);
 279
 280   /* do something with the value */
 281   fixed ^= 1;
 282
 283   /* set new value */
 284   gtk_list_store_set (GTK_LIST_STORE (model), &iter, LST_DEFACC_TOGGLE, fixed, -1);
 285
 286   /* clean up */
 287   gtk_tree_path_free (path);
 288 }
 289
 290 static gint
 291 ui_acc_listview_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
 292 {
 293 gint retval = 0;
 294 Account *entry1, *entry2;
 295 //gchar *name1, *name2;
 296
 297     gtk_tree_model_get(model, a, LST_DEFACC_DATAS, &entry1, -1);
 298     gtk_tree_model_get(model, b, LST_DEFACC_DATAS, &entry2, -1);
 299
 300         retval = entry1->pos - entry2->pos;
 301
 302     return retval;
 303 }
 304
 305
 306 static void
 307 ui_acc_listview_icon_cell_data_function (GtkTreeViewColumn *col,
 308                                 GtkCellRenderer *renderer,
 309                                 GtkTreeModel *model,
 310                                 GtkTreeIter *iter,
 311                                 gpointer user_data)
 312 {
 313 Account *entry;
 314 gchar *iconname = NULL;
 315
 316         gtk_tree_model_get(model, iter, LST_DEFACC_DATAS, &entry, -1);
 317         if( entry->flags & AF_CLOSED )
 318                 iconname = ICONNAME_CHANGES_PREVENT;
 319         g_object_set(renderer, "icon-name", iconname, NULL);
 320 }
 321
 322
 323 static void
 324 ui_acc_listview_name_cell_data_function (GtkTreeViewColumn *col,
 325                                 GtkCellRenderer *renderer,
 326                                 GtkTreeModel *model,
 327                                 GtkTreeIter *iter,
 328                                 gpointer user_data)
 329 {
 330 Account *entry;
 331 gchar *name;
 332 #if MYDEBUG
 333 gchar *string;
 334 #endif
 335
 336         gtk_tree_model_get(model, iter, LST_DEFACC_DATAS, &entry, -1);
 337         if(entry->name == NULL)
 338                 name = _("(none)");             // can never occurs !
 339         else
 340                 name = entry->name;
 341
 342         #if MYDEBUG
 343                 string = g_strdup_printf ("[%d] %s", entry->key, name );
 344                 g_object_set(renderer, "text", string, NULL);
 345                 g_free(string);
 346         #else
 347                 g_object_set(renderer, "text", name, NULL);
 348         #endif
 349
 350 }
 351
 352
 353
 354 /* = = = = = = = = = = = = = = = = */
 355
 356 /**
 357  * acc_list_add:
 358  *
 359  * Add a single element (useful for dynamics add)
 360  *
 361  * Return value: --
 362  *
 363  */
 364 void
 365 ui_acc_listview_add(GtkTreeView *treeview, Account *item)
 366 {
 367         if( item->name != NULL )
 368         {
 369         GtkTreeModel *model;
 370         GtkTreeIter     iter;
 371
 372                 model = gtk_tree_view_get_model(treeview);
 373
 374                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 375                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 376                         LST_DEFACC_TOGGLE, FALSE,
 377                         LST_DEFACC_DATAS, item,
 378                         -1);
 379
 380                 gtk_tree_selection_select_iter (gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), &iter);
 381
 382         }
 383 }
 384
 385 guint32
 386 ui_acc_listview_get_selected_key(GtkTreeView *treeview)
 387 {
 388 GtkTreeSelection *selection;
 389 GtkTreeModel             *model;
 390 GtkTreeIter                      iter;
 391
 392         selection = gtk_tree_view_get_selection(treeview);
 393         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 394         {
 395         Account *item;
 396
 397                 gtk_tree_model_get(model, &iter, LST_DEFACC_DATAS, &item, -1);
 398
 399                 if( item!= NULL  )
 400                         return item->key;
 401         }
 402         return 0;
 403 }
 404
 405 void
 406 ui_acc_listview_remove_selected(GtkTreeView *treeview)
 407 {
 408 GtkTreeSelection *selection;
 409 GtkTreeModel             *model;
 410 GtkTreeIter                      iter;
 411
 412         selection = gtk_tree_view_get_selection(treeview);
 413         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 414         {
 415                 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 416         }
 417 }
 418
 419
 420 static gint ui_acc_glist_compare_func(Account *a, Account *b)
 421 {
 422         return ((gint)a->pos - b->pos);
 423 }
 424
 425
 426 void ui_acc_listview_populate(GtkWidget *view, gint insert_type)
 427 {
 428 GtkTreeModel *model;
 429 GtkTreeIter     iter;
 430 GList *lacc, *list;
 431
 432         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 433
 434         gtk_list_store_clear (GTK_LIST_STORE(model));
 435
 436         g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
 437         gtk_tree_view_set_model(GTK_TREE_VIEW(view), NULL); /* Detach model from view */
 438
 439         /* populate */
 440         //g_hash_table_foreach(GLOBALS->h_acc, (GHFunc)ui_acc_listview_populate_ghfunc, model);
 441         list = g_hash_table_get_values(GLOBALS->h_acc);
 442
 443         lacc = list = g_list_sort(list, (GCompareFunc)ui_acc_glist_compare_func);
 444         while (list != NULL)
 445         {
 446         Account *item = list->data;
 447
 448                 if( insert_type == ACC_LST_INSERT_REPORT )
 449                 {
 450                         //#1674045 ony rely on nosummary
 451                         //if( (item->flags & AF_CLOSED) ) goto next1;
 452                         if( (item->flags & AF_NOREPORT) ) goto next1;
 453                 }
 454
 455                 DB( g_print(" populate: %d\n", item->key) );
 456
 457                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 458                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 459                         LST_DEFACC_TOGGLE       , FALSE,
 460                         LST_DEFACC_DATAS, item,
 461                         -1);
 462
 463 next1:
 464                 list = g_list_next(list);
 465         }
 466         g_list_free(lacc);
 467
 468         gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); /* Re-attach model to view */
 469         g_object_unref(model);
 470 }
 471
 472
 473 GtkWidget *
 474 ui_acc_listview_new(gboolean withtoggle)
 475 {
 476 GtkListStore *store;
 477 GtkWidget *treeview;
 478 GtkCellRenderer         *renderer;
 479 GtkTreeViewColumn       *column;
 480
 481         // create list store
 482         store = gtk_list_store_new(NUM_LST_DEFACC,
 483                 G_TYPE_BOOLEAN,
 484                 G_TYPE_POINTER
 485                 );
 486
 487         // treeview
 488         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 489         g_object_unref(store);
 490
 491         gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (treeview), PREFS->grid_lines);
 492
 493         // column 1: toggle
 494         if( withtoggle == TRUE )
 495         {
 496                 renderer = gtk_cell_renderer_toggle_new ();
 497                 column = gtk_tree_view_column_new_with_attributes (_("Visible"),
 498                                                              renderer,
 499                                                              "active", LST_DEFACC_TOGGLE,
 500                                                              NULL);
 501                 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 502
 503                 g_signal_connect (renderer, "toggled",
 504                             G_CALLBACK (ui_acc_listview_toggled_cb), store);
 505
 506         }
 507
 508         // column 2: name
 509         column = gtk_tree_view_column_new();
 510
 511         renderer = gtk_cell_renderer_text_new ();
 512         g_object_set(renderer,
 513                 "ellipsize", PANGO_ELLIPSIZE_END,
 514             "ellipsize-set", TRUE,
 515             NULL);
 516
 517         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 518         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_acc_listview_name_cell_data_function, GINT_TO_POINTER(LST_DEFACC_DATAS), NULL);
 519
 520     renderer = gtk_cell_renderer_pixbuf_new ();
 521     gtk_tree_view_column_pack_start(column, renderer, TRUE);
 522     gtk_tree_view_column_set_cell_data_func(column, renderer, ui_acc_listview_icon_cell_data_function, GINT_TO_POINTER(LST_DEFACC_DATAS), NULL);
 523
 524
 525         gtk_tree_view_column_set_resizable(column, TRUE);
 526         gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 527
 528         // treeviewattribute
 529         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview), FALSE);
 530         gtk_tree_view_set_reorderable (GTK_TREE_VIEW(treeview), TRUE);
 531
 532         gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), ui_acc_listview_compare_func, NULL, NULL);
 533         //gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 534
 535         return treeview;
 536 }
 537
 538 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 539
 540 /*
 541 ** get widgets contents to the selected account
 542 */
 543 /*
 544 static void ui_acc_manage_get(GtkWidget *widget, gpointer user_data)
 545 {
 546 struct ui_acc_manage_data *data;
 547 GtkTreeSelection *selection;
 548 GtkTreeModel             *model;
 549 GtkTreeIter                      iter;
 550 gchar *txt;
 551 gboolean bool;
 552 gdouble value;
 553
 554 Account *item;
 555
 556 gint field = GPOINTER_TO_INT(user_data);
 557
 558         DB( g_print("(ui_acc_manage_) get %d\n", field) );
 559
 560         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 561
 562         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_acc));
 563         //if true there is a selected node
 564         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 565         {
 566                 gtk_tree_model_get(model, &iter, LST_DEFACC_DATAS, &item, -1);
 567
 568                 data->change++;
 569
 570                 switch( field )
 571                 {
 572                         case FIELD_NAME:
 573                                 txt = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_name));
 574                                 // ignore if entry is empty
 575                                 if (txt && *txt)
 576                                 {
 577                                         bool = account_rename(item, txt);
 578                                         if(bool)
 579                                         {
 580                                                 gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_acc));
 581                                         }
 582                                         else
 583                                         {
 584                                                 gtk_entry_set_text(GTK_ENTRY(data->ST_name), item->name);
 585                                         }
 586                                 }
 587                                 break;
 588
 589                         //case FIELD_TYPE:
 590                         //      item->type = gtk_combo_box_get_active(GTK_COMBO_BOX(data->CY_type));
 591                         //      break;
 592
 593                         case FIELD_BANK:
 594                                 g_free(item->bankname);
 595                                 item->bankname = g_strdup(gtk_entry_get_text(GTK_ENTRY(data->ST_institution)));
 596                                 break;
 597
 598                         case FIELD_NUMBER:
 599                                 g_free(item->number);
 600                                 item->number = g_strdup(gtk_entry_get_text(GTK_ENTRY(data->ST_number)));
 601                                 break;
 602
 603                         case FIELD_BUDGET:
 604                                 item->flags &= ~(AF_BUDGET);
 605                                 bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_nobudget));
 606                                 if(bool) item->flags |= AF_BUDGET;
 607                                 break;
 608
 609                         case FIELD_CLOSED:
 610                                 item->flags &= ~(AF_CLOSED);
 611                                 bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_closed));
 612                                 if(bool) item->flags |= AF_CLOSED;
 613                                 break;
 614
 615                         case FIELD_INITIAL:
 616                                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_initial));
 617                                 item->initial = value;
 618                                 break;
 619
 620                         case FIELD_MINIMUM:
 621                                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_overdraft));
 622                                 item->minimum = value;
 623                                 break;
 624
 625                         case FIELD_CHEQUE1:
 626                                 item->cheque1 = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(data->ST_cheque1));
 627                                 break;
 628
 629                         case FIELD_CHEQUE2:
 630                                 item->cheque2 = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(data->ST_cheque2));
 631                                 break;
 632                 }
 633         }
 634
 635 }
 636 */
 637
 638
 639 static gchar *dialog_get_name(gchar *title, gchar *origname, GtkWindow *parentwindow)
 640 {
 641 GtkWidget *dialog, *content, *mainvbox, *getwidget;
 642 gchar *retval = NULL;
 643
 644                 dialog = gtk_dialog_new_with_buttons (title,
 645                                                     GTK_WINDOW (parentwindow),
 646                                                     0,
 647                                                     _("_Cancel"),
 648                                                     GTK_RESPONSE_REJECT,
 649                                                     _("_OK"),
 650                                                     GTK_RESPONSE_ACCEPT,
 651                                                     NULL);
 652
 653                 content = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
 654
 655                 mainvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 656                 gtk_box_pack_start (GTK_BOX (content), mainvbox, TRUE, TRUE, 0);
 657                 gtk_container_set_border_width (GTK_CONTAINER (mainvbox), SPACING_SMALL);
 658
 659                 getwidget = gtk_entry_new();
 660                 gtk_box_pack_start (GTK_BOX (mainvbox), getwidget, TRUE, TRUE, 0);
 661                 gtk_widget_show_all(mainvbox);
 662
 663                 if(origname != NULL)
 664                         gtk_entry_set_text(GTK_ENTRY(getwidget), origname);
 665                 gtk_widget_grab_focus (getwidget);
 666
 667                 gtk_entry_set_activates_default (GTK_ENTRY(getwidget), TRUE);
 668
 669                 gtk_dialog_set_default_response(GTK_DIALOG( dialog ), GTK_RESPONSE_ACCEPT);
 670
 671                 //wait for the user
 672                 gint result = gtk_dialog_run (GTK_DIALOG (dialog));
 673
 674                 if(result == GTK_RESPONSE_ACCEPT)
 675                 {
 676                 const gchar *name;
 677
 678                         name = gtk_entry_get_text(GTK_ENTRY(getwidget));
 679
 680                         /* ignore if entry is empty */
 681                         if (name && *name)
 682                         {
 683                                 retval = g_strdup(name);
 684                         }
 685             }
 686
 687                 // cleanup and destroy
 688                 gtk_widget_destroy (dialog);
 689
 690
 691         return retval;
 692 }
 693
 694
 695
 696
 697
 698 static void ui_acc_manage_getlast(struct ui_acc_manage_data *data)
 699 {
 700 gboolean bool;
 701 gdouble value;
 702 Account *item;
 703
 704         DB( g_print("\n(ui_acc_manage_getlast)\n") );
 705
 706         DB( g_print(" -> for account id=%d\n", data->lastkey) );
 707
 708         item = da_acc_get(data->lastkey);
 709         if(item != NULL)
 710         {
 711                 data->change++;
 712
 713                 item->type = hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_type));
 714
 715                 account_set_currency(item, ui_cur_combobox_get_key(GTK_COMBO_BOX(data->CY_curr)) );
 716
 717                 g_free(item->bankname);
 718                 item->bankname = g_strdup(gtk_entry_get_text(GTK_ENTRY(data->ST_institution)));
 719
 720                 g_free(item->number);
 721                 item->number = g_strdup(gtk_entry_get_text(GTK_ENTRY(data->ST_number)));
 722
 723                 GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (data->TB_notes));
 724                 GtkTextIter siter, eiter;
 725                 gchar *notes;
 726
 727                 gtk_text_buffer_get_iter_at_offset (buffer, &siter, 0);
 728                 gtk_text_buffer_get_end_iter(buffer, &eiter);
 729                 notes = gtk_text_buffer_get_text(buffer, &siter, &eiter, FALSE);
 730                 if(notes != NULL)
 731                         item->notes = g_strdup(notes);
 732
 733                 item->flags &= ~(AF_CLOSED);
 734                 bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_closed));
 735                 if(bool) item->flags |= AF_CLOSED;
 736
 737                 item->flags &= ~(AF_NOBUDGET);
 738                 bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_nobudget));
 739                 if(bool) item->flags |= AF_NOBUDGET;
 740
 741                 item->flags &= ~(AF_NOSUMMARY);
 742                 bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_nosummary));
 743                 if(bool) item->flags |= AF_NOSUMMARY;
 744
 745                 item->flags &= ~(AF_NOREPORT);
 746                 bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_noreport));
 747                 if(bool) item->flags |= AF_NOREPORT;
 748
 749                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->ST_initial));
 750                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_initial));
 751                 item->initial = value;
 752
 753                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->ST_overdraft));
 754                 value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(data->ST_overdraft));
 755                 item->minimum = value;
 756
 757                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->ST_cheque1));
 758                 item->cheque1 = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(data->ST_cheque1));
 759
 760                 gtk_spin_button_update(GTK_SPIN_BUTTON(data->ST_cheque2));
 761                 item->cheque2 = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(data->ST_cheque2));
 762
 763                 item->karc= hbtk_combo_box_get_active_id(GTK_COMBO_BOX_TEXT(data->CY_template));
 764                 //active_id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(data->CY_template));
 765                 //item->karc = atoi(active_id);
 766         }
 767
 768 }
 769
 770
 771 //#1743254 set frac digits as well
 772 static void ui_acc_manage_changed_curr_cb(GtkWidget *widget, gpointer user_data)
 773 {
 774 struct ui_acc_manage_data *data;
 775 guint32 key;
 776 Currency *cur;
 777
 778         DB( g_print("\n(ui_acc_manage changed_curr_cb)\n") );
 779
 780         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 781
 782         key = ui_cur_combobox_get_key(GTK_COMBO_BOX(data->CY_curr));
 783         cur = da_cur_get (key);
 784         if( cur != NULL )
 785         {
 786                 DB( g_print("- set digits to '%s' %d\n", cur->name, cur->frac_digits) );
 787                 gtk_spin_button_set_digits (GTK_SPIN_BUTTON(data->ST_initial), cur->frac_digits);
 788                 gtk_spin_button_set_digits (GTK_SPIN_BUTTON(data->ST_overdraft), cur->frac_digits);
 789         }
 790
 791 }
 792
 793
 794 /*
 795 ** set widgets contents from the selected account
 796 */
 797 static void ui_acc_manage_set(GtkWidget *widget, gpointer user_data)
 798 {
 799 struct ui_acc_manage_data *data;
 800 GtkTreeSelection *selection;
 801 GtkTreeModel             *model;
 802 GtkTreeIter                      iter;
 803 Account *item;
 804
 805         DB( g_print("\n(ui_acc_manage_set)\n") );
 806
 807         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 808
 809         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_acc));
 810         //if true there is a selected node
 811         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 812         {
 813                 gtk_tree_model_get(model, &iter, LST_DEFACC_DATAS, &item, -1);
 814
 815                 DB( g_print(" -> set acc id=%d\n", item->key) );
 816
 817                 hbtk_combo_box_set_active_id(GTK_COMBO_BOX_TEXT(data->CY_type), item->type );
 818
 819                 ui_cur_combobox_set_active(GTK_COMBO_BOX(data->CY_curr), item->kcur);
 820
 821                 if(item->bankname != NULL)
 822                         gtk_entry_set_text(GTK_ENTRY(data->ST_institution), item->bankname);
 823                 else
 824                         gtk_entry_set_text(GTK_ENTRY(data->ST_institution), "");
 825
 826                 if(item->number != NULL)
 827                         gtk_entry_set_text(GTK_ENTRY(data->ST_number), item->number);
 828                 else
 829                         gtk_entry_set_text(GTK_ENTRY(data->ST_number), "");
 830
 831                 GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (data->TB_notes));
 832                 GtkTextIter iter;
 833
 834                 gtk_text_buffer_set_text (buffer, "", 0);
 835                 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
 836                 if(item->notes != NULL)
 837                         gtk_text_buffer_insert (buffer, &iter, item->notes, -1);
 838
 839                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_nobudget), item->flags & AF_NOBUDGET);
 840                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_nosummary), item->flags & AF_NOSUMMARY);
 841                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_noreport), item->flags & AF_NOREPORT);
 842                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_closed), item->flags & AF_CLOSED);
 843
 844                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_initial), item->initial);
 845                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_overdraft), item->minimum);
 846
 847                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_cheque1), item->cheque1);
 848                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->ST_cheque2), item->cheque2);
 849
 850                 hbtk_combo_box_set_active_id(GTK_COMBO_BOX_TEXT(data->CY_template), item->karc);
 851                 //g_snprintf(idbuffer, 11, "%d", item->karc);
 852                 //gtk_combo_box_set_active_id(GTK_COMBO_BOX(data->CY_template), idbuffer);
 853
 854         }
 855
 856 }
 857
 858 /*
 859 static gboolean ui_acc_manage_focus_out(GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
 860 {
 861         ui_acc_manage_get(widget, user_data);
 862         return FALSE;
 863 }
 864 */
 865
 866 /*
 867 ** update the widgets status and contents from action/selection value
 868 */
 869 static void ui_acc_manage_update(GtkWidget *widget, gpointer user_data)
 870 {
 871 struct ui_acc_manage_data *data;
 872 GtkTreeModel             *model;
 873 GtkTreeIter                      iter;
 874 gboolean selected, sensitive;
 875 guint32 key;
 876 //gboolean is_new;
 877
 878         DB( g_print("\n(ui_acc_manage_update)\n") );
 879
 880         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 881         //window = gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW);
 882         //DB( g_print("(defpayee) widget=%08lx, window=%08lx, inst_data=%08lx\n", treeview, window, data) );
 883
 884         //if true there is a selected node
 885         selected = gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_acc)), &model, &iter);
 886         key = ui_acc_listview_get_selected_key(GTK_TREE_VIEW(data->LV_acc));
 887
 888         DB( g_print(" -> selected = %d  action = %d key = %d\n", selected, data->action, key) );
 889
 890         //todo amiga/linux
 891         /*
 892         if(acc)
 893         {
 894         // check for archives related
 895                 for(i=0;;i++)
 896                 {
 897                 struct Archive *arc;
 898
 899                         DoMethod(data->mwd->LV_arc, MUIM_List_GetEntry, i, &arc);
 900                         if(!arc) break;
 901                         if(arc->arc_Account == acc->acc_Id)
 902                         { nbarc++; break; }
 903                 }
 904
 905         // check for transaction related
 906                 for(i=0;;i++)
 907                 {
 908                 struct Transaction *ope;
 909
 910                         DoMethod(data->mwd->LV_ope, MUIM_List_GetEntry, i, &ope);
 911                         if(!ope) break;
 912                         if(ope->ope_Account == acc->acc_Id)
 913                         { nbope++; break; }
 914                 }
 915         }       */
 916
 917         //todo: lock type if oldpos!=0
 918 /*
 919         if( selected )
 920         {
 921                 gtk_tree_model_get(model, &iter,
 922                         LST_DEFACC_NEW, &is_new,
 923                         -1);
 924                 gtk_widget_set_sensitive(data->CY_type, is_new);
 925         }
 926 */
 927
 928         sensitive = (selected == TRUE) ? TRUE : FALSE;
 929
 930         gtk_widget_set_sensitive(data->notebook, sensitive);
 931
 932         sensitive = (selected == TRUE && data->action == 0) ? TRUE : FALSE;
 933         //gtk_widget_set_sensitive(data->BT_mod, sensitive);
 934         gtk_widget_set_sensitive(data->BT_rem, sensitive);
 935
 936         if(selected)
 937         {
 938                 if(key != data->lastkey)
 939                 {
 940                         DB( g_print(" -> should first do a get for account %d\n", data->lastkey) );
 941                         ui_acc_manage_getlast(data);
 942                 }
 943
 944                 ui_acc_manage_set(widget, NULL);
 945         }
 946
 947         data->lastkey = key;
 948
 949 }
 950
 951
 952 /*
 953 ** add an empty new account to our temp GList and treeview
 954 */
 955 static void ui_acc_manage_add(GtkWidget *widget, gpointer user_data)
 956 {
 957 struct ui_acc_manage_data *data;
 958 Account *item;
 959
 960         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 961         DB( g_print("\n(ui_acc_manage_add) data=%p\n", data) );
 962
 963         gchar *name = dialog_get_name(_("Account name"), NULL, GTK_WINDOW(data->window));
 964         if(name != NULL)
 965         {
 966                 if(account_exists(name))
 967                 {
 968                         ui_dialog_msg_infoerror(GTK_WINDOW(data->window), GTK_MESSAGE_ERROR,
 969                                 _("Error"),
 970                                 _("Cannot add an account '%s',\n"
 971                                 "this name already exists."),
 972                                 name
 973                                 );
 974                 }
 975                 else
 976                 {
 977                         item = da_acc_malloc();
 978                         item->name = name; //g_strdup_printf( _("(account %d)"), da_acc_length()+1);
 979                         item->kcur = GLOBALS->kcur;
 980
 981                         g_strstrip(item->name);
 982
 983                         if( strlen(item->name) > 0 )
 984                         {
 985                                 if( da_acc_append(item) )
 986                                 {
 987                                         ui_acc_listview_add(GTK_TREE_VIEW(data->LV_acc), item);
 988                                         data->change++;
 989                                 }
 990                         }
 991                 }
 992         }
 993 }
 994
 995 /*
 996 ** delete the selected account to our treeview and temp GList
 997 */
 998 static void ui_acc_manage_delete(GtkWidget *widget, gpointer user_data)
 999 {
1000 struct ui_acc_manage_data *data;
1001 Account *item;
1002 guint32 key;
1003 gint result;
1004
1005         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1006         DB( g_print("\n(ui_acc_manage_remove) data=%p\n", data) );
1007
1008         key = ui_acc_listview_get_selected_key(GTK_TREE_VIEW(data->LV_acc));
1009         if( key > 0 )
1010         {
1011                 item = da_acc_get(key);
1012
1013                 if( account_is_used(key) == TRUE )
1014                 {
1015                 gchar *title;
1016
1017                         title = g_strdup_printf (
1018                                 _("Cannot delete account '%s'"), item->name);
1019
1020                         ui_dialog_msg_infoerror(GTK_WINDOW(data->window), GTK_MESSAGE_ERROR,
1021                                 title,
1022                                 _("This account contains transactions and/or is part of internal transfers.")
1023                         );
1024
1025                         g_free(title);
1026                 }
1027                 else
1028                 {
1029                 gchar *title;
1030                 gchar *secondtext;
1031
1032                         title = g_strdup_printf (
1033                                 _("Are you sure you want to permanently delete '%s'?"), item->name);
1034
1035                         secondtext = _("If you delete an account, it will be permanently lost.");
1036
1037                         result = ui_dialog_msg_confirm_alert(
1038                                         GTK_WINDOW(data->window),
1039                                         title,
1040                                         secondtext,
1041                                         _("_Delete")
1042                                 );
1043
1044                         g_free(title);
1045
1046                         if( result == GTK_RESPONSE_OK )
1047                         {
1048                                 da_acc_remove(key);
1049                                 ui_acc_listview_remove_selected(GTK_TREE_VIEW(data->LV_acc));
1050                                 data->change++;
1051                         }
1052
1053                 }
1054         }
1055 }
1056
1057
1058 /*
1059 ** rename the selected account to our treeview and temp GList
1060 */
1061 static void ui_acc_manage_rename(GtkWidget *widget, gpointer user_data)
1062 {
1063 struct ui_acc_manage_data *data;
1064 Account *item;
1065 guint32 key;
1066 gboolean bool;
1067
1068         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1069         DB( g_print("\n(ui_acc_manage_rename) data=%p\n", data) );
1070
1071         key = ui_acc_listview_get_selected_key(GTK_TREE_VIEW(data->LV_acc));
1072         if( key > 0 )
1073         {
1074                 item = da_acc_get(key);
1075
1076                 gchar *name = dialog_get_name(_("Account name"), item->name, GTK_WINDOW(data->window));
1077                 if(name != NULL)
1078                 {
1079                         if(account_exists(name))
1080                         {
1081                                 ui_dialog_msg_infoerror(GTK_WINDOW(data->window), GTK_MESSAGE_ERROR,
1082                                         _("Error"),
1083                                         _("Cannot rename this Account,\n"
1084                                         "from '%s' to '%s',\n"
1085                                         "this name already exists."),
1086                                         item->name,
1087                                         name
1088                                     );
1089                         }
1090                         else
1091                         {
1092                                 bool = account_rename(item, name);
1093                                 if(bool)
1094                                 {
1095                                         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_acc));
1096                                         data->change++;
1097                                 }
1098                         }
1099
1100                 }
1101
1102         }
1103 }
1104
1105
1106 static void ui_acc_manage_toggled_closed(GtkWidget *widget, gpointer user_data)
1107 {
1108 struct ui_acc_manage_data *data;
1109 GtkTreeModel             *model;
1110 GtkTreeIter                      iter;
1111 GtkTreePath                     *path;
1112 Account         *accitem;
1113 gboolean selected, bool;
1114
1115         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1116         DB( g_print("\n(ui_acc_manage_toggled_closed) data=%p\n", data) );
1117
1118         selected = gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_acc)), &model, &iter);
1119
1120         if(selected)
1121         {
1122                 gtk_tree_model_get(model, &iter, LST_DEFACC_DATAS, &accitem, -1);
1123                 accitem->flags &= ~(AF_CLOSED);
1124                 bool = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_closed));
1125                 if(bool) accitem->flags |= AF_CLOSED;
1126
1127                 /* redraw the row to display/hide the icon */
1128                 path = gtk_tree_model_get_path(model, &iter);
1129                 gtk_tree_model_row_changed(model, path, &iter);
1130                 gtk_tree_path_free (path);
1131
1132                 //      gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_arc));
1133                 //gtk_widget_queue_draw (GTK_WIDGET(data->LV_arc));
1134         }
1135
1136 }
1137
1138
1139 static void ui_acc_manage_rowactivated (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *col, gpointer userdata)
1140 {
1141 //struct account_data *data;
1142
1143         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW)), "inst_data");
1144
1145         ui_acc_manage_rename(GTK_WIDGET(treeview), NULL);
1146
1147 }
1148
1149
1150
1151
1152 /*
1153 **
1154 */
1155 static void ui_acc_manage_selection(GtkTreeSelection *treeselection, gpointer user_data)
1156 {
1157         ui_acc_manage_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
1158 }
1159
1160 //gint ui_acc_manage_list_sort(struct _Account *a, struct _Account *b) { return( a->acc_Id - b->acc_Id); }
1161
1162 /*
1163 **
1164 */
1165 static gboolean ui_acc_manage_cleanup(struct ui_acc_manage_data *data, gint result)
1166 {
1167 GtkTreeModel *model;
1168 GtkTreeIter     iter;
1169 gboolean valid;
1170 guint32 i;
1171 guint32 key;
1172 gboolean doupdate = FALSE;
1173
1174         DB( g_print("\n(ui_acc_manage_cleanup) %p\n", data) );
1175
1176                 key = ui_acc_listview_get_selected_key(GTK_TREE_VIEW(data->LV_acc));
1177                 if(key > 0)
1178                 {
1179                         data->lastkey = key;
1180                         DB( g_print(" -> should first do a get for account %d\n", data->lastkey) );
1181                         ui_acc_manage_getlast(data);
1182                 }
1183
1184                 // test for change & store new position
1185                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_acc));
1186                 i=1; valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
1187                 while (valid)
1188                 {
1189                 Account *item;
1190
1191                         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
1192                                 LST_DEFACC_DATAS, &item,
1193                                 -1);
1194
1195                         DB( g_print(" -> check acc %d, pos is %d, %s\n", i, item->pos, item->name) );
1196
1197                         if(item->pos != i)
1198                                 data->change++;
1199
1200                         item->pos = i;
1201
1202                         // Make iter point to the next row in the list store
1203                         i++; valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
1204                 }
1205
1206         GLOBALS->changes_count += data->change;
1207
1208         return doupdate;
1209 }
1210
1211 /*
1212 **
1213 */
1214 static void ui_acc_manage_setup(struct ui_acc_manage_data *data)
1215 {
1216 GList *tmplist;
1217
1218         DB( g_print("\n(ui_acc_manage_setup)\n") );
1219
1220         //init GList
1221         data->tmp_list = NULL; //hb-glist_clone_list(GLOBALS->acc_list, sizeof(struct _Account));
1222         data->action = 0;
1223         data->change = 0;
1224         data->lastkey = 0;
1225
1226         ui_acc_listview_populate(data->LV_acc, ACC_LST_INSERT_NORMAL);
1227         ui_cur_combobox_populate(GTK_COMBO_BOX(data->CY_curr), GLOBALS->h_cur);
1228         //populate_view_acc(data->LV_acc, GLOBALS->acc_list, TRUE);
1229
1230         //populate template
1231         hbtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(data->CY_template), 0, _("(none)"));
1232         gtk_combo_box_set_active(GTK_COMBO_BOX(data->CY_template), 0);
1233         tmplist = g_list_first(GLOBALS->arc_list);
1234         while (tmplist != NULL)
1235         {
1236         Archive *item = tmplist->data;
1237
1238                 if( !(item->flags & OF_AUTO) )
1239                 {
1240                         hbtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(data->CY_template), item->key, item->memo);
1241                 }
1242                 tmplist = g_list_next(tmplist);
1243         }
1244
1245 }
1246
1247 /*
1248 **
1249 */
1250 GtkWidget *ui_acc_manage_dialog (void)
1251 {
1252 struct ui_acc_manage_data data;
1253 GtkWidget *dialog, *content, *mainbox, *vbox, *scrollwin, *notebook;
1254 GtkWidget *content_grid, *group_grid;
1255 GtkWidget *table, *label, *widget, *hpaned;
1256 gint w, h, row;
1257
1258         dialog = gtk_dialog_new_with_buttons (_("Manage Accounts"),
1259                                 GTK_WINDOW(GLOBALS->mainwindow),
1260                                 0,
1261                             _("_Close"),
1262                             GTK_RESPONSE_ACCEPT,
1263                                 NULL);
1264
1265         data.window = dialog;
1266
1267         //set the dialog icon
1268         gtk_window_set_icon_name(GTK_WINDOW (dialog), ICONNAME_HB_ACCOUNT);
1269
1270         //set a nice dialog size
1271         gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
1272         gtk_window_set_default_size (GTK_WINDOW(dialog), -1, h/PHI);
1273
1274         //store our dialog private data
1275         g_object_set_data(G_OBJECT(dialog), "inst_data", (gpointer)&data);
1276         DB( g_print("(ui_acc_manage_) dialog=%p, inst_data=%p\n", dialog, &data) );
1277
1278         //window contents
1279         content = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
1280         mainbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1281         gtk_box_pack_start (GTK_BOX (content), mainbox, TRUE, TRUE, 0);
1282         gtk_container_set_border_width (GTK_CONTAINER(mainbox), SPACING_MEDIUM);
1283
1284         hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
1285         gtk_box_pack_start (GTK_BOX (mainbox), hpaned, TRUE, TRUE, 0);
1286
1287         // set paned position
1288         //w = w/PHI;
1289         //gtk_paned_set_position(GTK_PANED(hpaned), w - (w/PHI));
1290
1291         /* left area */
1292         vbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
1293         //gtk_box_pack_start (GTK_BOX (mainbox), vbox, FALSE, FALSE, 0);
1294         gtk_widget_set_margin_right(vbox, SPACING_TINY);
1295         gtk_paned_pack1 (GTK_PANED(hpaned), vbox, FALSE, FALSE);
1296
1297         table = gtk_grid_new ();
1298         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_SMALL);
1299         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_SMALL);
1300         gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
1301
1302         row = 0;
1303         scrollwin = gtk_scrolled_window_new(NULL,NULL);
1304         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1305         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1306         data.LV_acc = ui_acc_listview_new(FALSE);
1307         gtk_widget_set_size_request(data.LV_acc, HB_MINWIDTH_LIST, -1);
1308         gtk_container_add(GTK_CONTAINER(scrollwin), data.LV_acc);
1309         gtk_widget_set_tooltip_text(data.LV_acc, _("Drag & drop to change the order\nDouble-click to rename"));
1310         gtk_widget_set_vexpand (scrollwin, TRUE);
1311         gtk_widget_set_hexpand (scrollwin, TRUE);
1312         gtk_grid_attach (GTK_GRID(table), scrollwin, 0, row, 2, 1);
1313
1314         row++;
1315         widget = gtk_button_new_with_mnemonic(_("_Add"));
1316         data.BT_add = widget;
1317         gtk_grid_attach (GTK_GRID(table), widget, 0, row, 1, 1);
1318
1319         widget = gtk_button_new_with_mnemonic(_("_Delete"));
1320         data.BT_rem = widget;
1321         gtk_grid_attach (GTK_GRID(table), widget, 1, row, 1, 1);
1322
1323
1324         /* right area */
1325         notebook = gtk_notebook_new();
1326         data.notebook = notebook;
1327         //gtk_box_pack_start (GTK_BOX (mainbox), notebook, TRUE, TRUE, 0);
1328         gtk_widget_set_margin_left(notebook, SPACING_TINY);
1329         gtk_paned_pack2 (GTK_PANED(hpaned), notebook, FALSE, FALSE);
1330
1331         /* page :: General */
1332         content_grid = gtk_grid_new();
1333         gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
1334         gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
1335         gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
1336         label = gtk_label_new(_("General"));
1337         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), content_grid, label);
1338
1339         // group :: Account
1340     group_grid = gtk_grid_new ();
1341         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1342         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1343         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 0, 1, 1);
1344
1345         label = make_label_group(_("Account"));
1346         gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
1347
1348         row = 1;
1349         label = make_label_widget(_("_Type:"));
1350         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1351         //widget = make_cycle(label, CYA_ACC_TYPE);
1352         widget = hbtk_combo_box_new_with_data(label, CYA_ACC_TYPE);
1353         data.CY_type = widget;
1354         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1355
1356         row++;
1357         label = make_label_widget(_("_Currency:"));
1358         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1359         widget = ui_cur_combobox_new(label);
1360         data.CY_curr = widget;
1361         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1362
1363         row++;
1364         label = make_label_widget(_("Start _balance:"));
1365         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1366         widget = make_amount(label);
1367         data.ST_initial = widget;
1368         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1369
1370         //TODO: notes
1371         row++;
1372         label = make_label_widget(_("Notes:"));
1373         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1374         widget = gtk_text_view_new ();
1375         //#1697171 add wrap
1376         gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD);
1377     scrollwin = gtk_scrolled_window_new (NULL, NULL);
1378         gtk_widget_set_size_request (scrollwin, -1, 48);
1379         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1380         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1381         gtk_container_add (GTK_CONTAINER (scrollwin), widget);
1382         gtk_widget_set_hexpand (scrollwin, TRUE);
1383         gtk_widget_set_vexpand (scrollwin, TRUE);
1384         data.TB_notes = widget;
1385         gtk_grid_attach (GTK_GRID (group_grid), scrollwin, 2, row, 1, 1);
1386
1387         row++;
1388         widget = gtk_check_button_new_with_mnemonic (_("this account was _closed"));
1389         data.CM_closed = widget;
1390         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1391
1392
1393         // group :: Current check number
1394     group_grid = gtk_grid_new ();
1395         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1396         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1397         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 1, 1, 1);
1398
1399         label = make_label_group(_("Current check number"));
1400         gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
1401
1402         row = 1;
1403         label = make_label_widget(_("Checkbook _1:"));
1404         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1405         widget = make_long (label);
1406         data.ST_cheque1 = widget;
1407         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1408
1409         row++;
1410         label = make_label_widget(_("Checkbook _2:"));
1411         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1412         widget = make_long (label);
1413         data.ST_cheque2 = widget;
1414         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1415
1416
1417         /* page :: Options */
1418         content_grid = gtk_grid_new();
1419         gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
1420         gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
1421         gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
1422         label = gtk_label_new(_("Options"));
1423         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), content_grid, label);
1424
1425         // group :: Institution
1426     group_grid = gtk_grid_new ();
1427         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1428         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1429         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 0, 1, 1);
1430
1431         label = make_label_group(_("Institution"));
1432         gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
1433
1434         row = 1;
1435         label = make_label_widget(_("_Name:"));
1436         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1437         widget = make_string(label);
1438         data.ST_institution = widget;
1439         gtk_widget_set_hexpand(widget, TRUE);
1440         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 2, 1);
1441
1442         row++;
1443         label = make_label_widget(_("N_umber:"));
1444         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1445         widget = make_string(label);
1446         data.ST_number = widget;
1447         gtk_widget_set_hexpand(widget, TRUE);
1448         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 2, 1);
1449
1450         // group :: Limits
1451     group_grid = gtk_grid_new ();
1452         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1453         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1454         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 1, 1, 1);
1455
1456         label = make_label_group(_("Balance limits"));
1457         gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
1458
1459         //TODO: warning/absolute minimum balance
1460
1461         row = 1;
1462         label = make_label_widget(_("_Overdraft at:"));
1463         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1464         widget = make_amount(label);
1465         data.ST_overdraft = widget;
1466         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
1467
1468         // group :: miscelleaneous
1469     group_grid = gtk_grid_new ();
1470         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1471         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1472         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 2, 1, 1);
1473
1474         label = make_label_group(_("Miscellaneous"));
1475         gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 2, 1);
1476
1477         row = 1;
1478         label = make_label_widget(_("Default _Template:"));
1479         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
1480         widget = hbtk_combo_box_new(label);
1481         data.CY_template = widget;
1482         gtk_widget_set_hexpand(widget, TRUE);
1483         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 2, 1);
1484
1485
1486         // group :: Report exclusion
1487     group_grid = gtk_grid_new ();
1488         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
1489         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
1490         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, 3, 1, 1);
1491
1492         label = make_label_group(_("Report exclusion"));
1493         gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 2, 1);
1494
1495         row = 1;
1496         widget = gtk_check_button_new_with_mnemonic (_("exclude from account _summary"));
1497         data.CM_nosummary = widget;
1498         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1499
1500         row++;
1501         widget = gtk_check_button_new_with_mnemonic (_("exclude from the _budget"));
1502         data.CM_nobudget = widget;
1503         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1504
1505         row++;
1506         widget = gtk_check_button_new_with_mnemonic (_("exclude from any _reports"));
1507         data.CM_noreport = widget;
1508         gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
1509
1510
1511         //connect all our signals
1512         g_signal_connect (dialog, "destroy", G_CALLBACK (gtk_widget_destroyed), &dialog);
1513         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data.LV_acc)), "changed", G_CALLBACK (ui_acc_manage_selection), NULL);
1514         g_signal_connect (GTK_TREE_VIEW(data.LV_acc), "row-activated", G_CALLBACK (ui_acc_manage_rowactivated), GINT_TO_POINTER(2));
1515
1516         g_signal_connect (data.CY_curr  , "changed", G_CALLBACK (ui_acc_manage_changed_curr_cb), NULL);
1517         g_signal_connect (data.CM_closed, "toggled", G_CALLBACK (ui_acc_manage_toggled_closed), NULL);
1518
1519         g_signal_connect (G_OBJECT (data.BT_add), "clicked", G_CALLBACK (ui_acc_manage_add), NULL);
1520         g_signal_connect (G_OBJECT (data.BT_rem), "clicked", G_CALLBACK (ui_acc_manage_delete), NULL);
1521
1522         //setup, init and show window
1523         ui_acc_manage_setup(&data);
1524         ui_acc_manage_update(data.LV_acc, NULL);
1525
1526         gtk_widget_show_all (dialog);
1527
1528         //wait for the user
1529         gint result = gtk_dialog_run (GTK_DIALOG (dialog));
1530
1531         // cleanup and destroy
1532         ui_acc_manage_cleanup(&data, result);
1533         gtk_widget_destroy (dialog);
1534
1535         return NULL;
1536 }
1537
1538