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

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