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

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