Dogcows Code - chaz/homebank/blob - src/ui-account.c

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