Dogcows Code - chaz/homebank/blob - src/ui-payee.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
  21 #include "homebank.h"
  22
  23 #include "ui-payee.h"
  24 #include "ui-category.h"
  25
  26 #define MYDEBUG 0
  27
  28 #if MYDEBUG
  29 #define DB(x) (x);
  30 #else
  31 #define DB(x);
  32 #endif
  33
  34 /* our global datas */
  35 extern struct HomeBank *GLOBALS;
  36 extern struct Preferences *PREFS;
  37
  38
  39 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  40
  41 /**
  42  * ui_pay_comboboxentry_get_name:
  43  *
  44  * get the name of the active payee or -1
  45  *
  46  * Return value: a new allocated name tobe freed with g_free
  47  *
  48  */
  49 gchar *
  50 ui_pay_comboboxentry_get_name(GtkComboBox *entry_box)
  51 {
  52 gchar *cbname;
  53 gchar *name = NULL;
  54
  55     DB( g_print ("ui_pay_comboboxentry_get_name()\n") );
  56
  57         cbname = (gchar *)gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))));
  58         if( cbname != NULL)
  59         {
  60                 name = g_strdup(cbname);
  61                 g_strstrip(name);
  62         }
  63
  64         return name;
  65 }
  66
  67
  68 /**
  69  * ui_pay_comboboxentry_get_key_add_new:
  70  *
  71  * get the key of the active payee
  72  * and create the payee if it do not exists
  73  *
  74  * Return value: the key or 0
  75  *
  76  */
  77 guint32
  78 ui_pay_comboboxentry_get_key_add_new(GtkComboBox *entry_box)
  79 {
  80 gchar *name;
  81 Payee *item;
  82
  83         name = ui_pay_comboboxentry_get_name(entry_box);
  84
  85         item = da_pay_get_by_name(name);
  86         if( item == NULL )
  87         {
  88                 /* automatic add */
  89                 //todo: check prefs + ask the user here 1st time
  90                 item = da_pay_malloc();
  91                 item->name = g_strdup(name);
  92                 da_pay_append(item);
  93                 ui_pay_comboboxentry_add(entry_box, item);
  94         }
  95
  96         g_free(name);
  97
  98         return item->key;
  99 }
 100
 101 /**
 102  * ui_pay_comboboxentry_get_key:
 103  *
 104  * get the key of the active payee
 105  *
 106  * Return value: the key or 0
 107  *
 108  */
 109 guint32
 110 ui_pay_comboboxentry_get_key(GtkComboBox *entry_box)
 111 {
 112 gchar *name;
 113 Payee *item;
 114
 115         name = ui_pay_comboboxentry_get_name(entry_box);
 116         item = da_pay_get_by_name(name);
 117         g_free(name);
 118
 119         if( item != NULL )
 120                 return item->key;
 121
 122         return 0;
 123 }
 124
 125
 126 Payee
 127 *ui_pay_comboboxentry_get(GtkComboBox *entry_box)
 128 {
 129 gchar *name;
 130 Payee *item = NULL;
 131
 132         DB( g_print ("ui_pay_comboboxentry_get()\n") );
 133
 134         name = (gchar *)gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))));
 135         item = da_pay_get_by_name(name);
 136
 137         return item;
 138 }
 139
 140
 141 gboolean
 142 ui_pay_comboboxentry_set_active(GtkComboBox *entry_box, guint32 key)
 143 {
 144 Payee *item;
 145
 146         if( key > 0 )
 147         {
 148                 item = da_pay_get(key);
 149                 if( item != NULL)
 150                 {
 151                         gtk_entry_set_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))), item->name);
 152                         return TRUE;
 153                 }
 154         }
 155         gtk_entry_set_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))), "");
 156         return FALSE;
 157 }
 158
 159 /**
 160  * ui_pay_comboboxentry_add:
 161  *
 162  * Add a single element (useful for dynamics add)
 163  *
 164  * Return value: --
 165  *
 166  */
 167 void
 168 ui_pay_comboboxentry_add(GtkComboBox *entry_box, Payee *pay)
 169 {
 170         if( pay->name != NULL )
 171         {
 172         GtkTreeModel *model;
 173         GtkTreeIter  iter;
 174
 175                 model = gtk_combo_box_get_model(GTK_COMBO_BOX(entry_box));
 176
 177                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 178                 gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, pay->name, -1);
 179         }
 180 }
 181
 182 static void
 183 ui_pay_comboboxentry_populate_ghfunc(gpointer key, gpointer value, struct payPopContext *ctx)
 184 {
 185 GtkTreeIter  iter;
 186 Payee *pay = value;
 187
 188         if( ( pay->key != ctx->except_key ) )
 189         {
 190                 //gtk_list_store_append (GTK_LIST_STORE(ctx->model), &iter);
 191                 //gtk_list_store_set (GTK_LIST_STORE(ctx->model), &iter, 0, pay->name, -1);
 192                 gtk_list_store_insert_with_values(GTK_LIST_STORE(ctx->model), &iter, -1,
 193                         0, pay->name, -1);
 194         }
 195 }
 196
 197 /**
 198  * ui_pay_comboboxentry_populate:
 199  *
 200  * Populate the list and completion
 201  *
 202  * Return value: --
 203  *
 204  */
 205 void
 206 ui_pay_comboboxentry_populate(GtkComboBox *entry_box, GHashTable *hash)
 207 {
 208         ui_pay_comboboxentry_populate_except(entry_box, hash, -1);
 209 }
 210
 211 void
 212 ui_pay_comboboxentry_populate_except(GtkComboBox *entry_box, GHashTable *hash, guint except_key)
 213 {
 214 GtkTreeModel *model;
 215 //GtkEntryCompletion *completion;
 216 struct payPopContext ctx;
 217
 218     DB( g_print ("ui_pay_comboboxentry_populate\n") );
 219
 220         model = gtk_combo_box_get_model(GTK_COMBO_BOX(entry_box));
 221         //completion = gtk_entry_get_completion(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (entry_box))));
 222
 223         /* keep our model alive and detach from comboboxentry and completion */
 224         //g_object_ref(model);
 225         //gtk_combo_box_set_model(GTK_COMBO_BOX(entry_box), NULL);
 226         //gtk_entry_completion_set_model (completion, NULL);
 227
 228         /* clear and populate */
 229         ctx.model = model;
 230         ctx.except_key = except_key;
 231         gtk_list_store_clear (GTK_LIST_STORE(model));
 232
 233         //gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(GTK_LIST_STORE(model)), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 234
 235         g_hash_table_foreach(hash, (GHFunc)ui_pay_comboboxentry_populate_ghfunc, &ctx);
 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         /* reatach our model */
 240         //g_print("reattach\n");
 241         //gtk_combo_box_set_model(GTK_COMBO_BOX(entry_box), model);
 242         //gtk_entry_completion_set_model (completion, model);
 243         //g_object_unref(model);
 244
 245 }
 246
 247
 248 static gint
 249 ui_pay_comboboxentry_compare_func (GtkTreeModel *model, GtkTreeIter  *a, GtkTreeIter  *b, gpointer      userdata)
 250 {
 251 gint retval = 0;
 252 gchar *name1, *name2;
 253
 254     gtk_tree_model_get(model, a, 0, &name1, -1);
 255     gtk_tree_model_get(model, b, 0, &name2, -1);
 256
 257         retval = hb_string_utf8_compare(name1, name2);
 258
 259     g_free(name2);
 260     g_free(name1);
 261
 262         return retval;
 263   }
 264
 265
 266 static void
 267 ui_pay_comboboxentry_test (GtkCellLayout   *cell_layout,
 268                    GtkCellRenderer *cell,
 269                    GtkTreeModel    *tree_model,
 270                    GtkTreeIter     *iter,
 271                    gpointer         data)
 272 {
 273 gchar *name;
 274
 275         gtk_tree_model_get(tree_model, iter,
 276                 0, &name,
 277                 -1);
 278
 279         if( !name )
 280                 g_object_set(cell, "text", _("(no payee)"), NULL);
 281         else
 282                 g_object_set(cell, "text", name, NULL);
 283
 284 }
 285
 286 /**
 287  * ui_pay_comboboxentry_new:
 288  *
 289  * Create a new payee comboboxentry
 290  *
 291  * Return value: the new widget
 292  *
 293  */
 294 GtkWidget *
 295 ui_pay_comboboxentry_new(GtkWidget *label)
 296 {
 297 GtkListStore *store;
 298 GtkWidget *comboboxentry;
 299 GtkEntryCompletion *completion;
 300 GtkCellRenderer    *renderer;
 301
 302     DB( g_print ("ui_pay_comboboxentry_new()\n") );
 303
 304         store = gtk_list_store_new (1,
 305                 G_TYPE_STRING
 306                 );
 307         gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), ui_pay_comboboxentry_compare_func, NULL, NULL);
 308
 309     completion = gtk_entry_completion_new ();
 310     gtk_entry_completion_set_model (completion, GTK_TREE_MODEL(store));
 311         g_object_set(completion, "text-column", 0, NULL);
 312
 313         renderer = gtk_cell_renderer_text_new ();
 314         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (completion), renderer, TRUE);
 315         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (completion), renderer, "text", 0, NULL);
 316
 317         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (completion),
 318                                             renderer,
 319                                             ui_pay_comboboxentry_test,
 320                                             NULL, NULL);
 321
 322         // dothe same for combobox
 323
 324         comboboxentry = gtk_combo_box_new_with_model_and_entry(GTK_TREE_MODEL(store));
 325         gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(comboboxentry), 0);
 326
 327         gtk_cell_layout_clear(GTK_CELL_LAYOUT (comboboxentry));
 328
 329         renderer = gtk_cell_renderer_text_new ();
 330         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (comboboxentry), renderer, TRUE);
 331         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (comboboxentry), renderer, "text", 0, NULL);
 332
 333         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (comboboxentry),
 334                                             renderer,
 335                                             ui_pay_comboboxentry_test,
 336                                             NULL, NULL);
 337
 338
 339
 340         gtk_entry_set_completion (GTK_ENTRY (gtk_bin_get_child(GTK_BIN (comboboxentry))), completion);
 341
 342         g_object_unref(store);
 343
 344         if(label)
 345                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), comboboxentry);
 346
 347         gtk_widget_set_size_request(comboboxentry, HB_MINWIDTH_LIST, -1);
 348
 349         return comboboxentry;
 350 }
 351
 352
 353 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 354
 355 static void
 356 ui_pay_listview_toggled_cb (GtkCellRendererToggle *cell,
 357                gchar                 *path_str,
 358                gpointer               data)
 359 {
 360   GtkTreeModel *model = (GtkTreeModel *)data;
 361   GtkTreeIter  iter;
 362   GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
 363   gboolean fixed;
 364
 365   /* get toggled iter */
 366   gtk_tree_model_get_iter (model, &iter, path);
 367   gtk_tree_model_get (model, &iter, LST_DEFPAY_TOGGLE, &fixed, -1);
 368
 369   /* do something with the value */
 370   fixed ^= 1;
 371
 372   /* set new value */
 373   gtk_list_store_set (GTK_LIST_STORE (model), &iter, LST_DEFPAY_TOGGLE, fixed, -1);
 374
 375   /* clean up */
 376   gtk_tree_path_free (path);
 377 }
 378
 379
 380 static gint
 381 ui_pay_listview_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
 382 {
 383 gint sortcol = GPOINTER_TO_INT(userdata);
 384 Payee *entry1, *entry2;
 385 gint retval = 0;
 386
 387         gtk_tree_model_get(model, a, LST_DEFPAY_DATAS, &entry1, -1);
 388         gtk_tree_model_get(model, b, LST_DEFPAY_DATAS, &entry2, -1);
 389
 390     switch (sortcol)
 391     {
 392                 case LST_DEFPAY_SORT_NAME:
 393                         retval = hb_string_utf8_compare(entry1->name, entry2->name);
 394                         break;
 395                 case LST_DEFPAY_SORT_USED:
 396                         retval = entry1->usage_count - entry2->usage_count;
 397                         break;
 398                 case LST_DEFPAY_SORT_DEFCAT:
 399                         {
 400                         Category *c1, *c2;
 401                         gchar *name1, *name2;
 402
 403                                 c1 = da_cat_get(entry1->kcat);
 404                                 c2 = da_cat_get(entry2->kcat);
 405                                 if( c1 != NULL && c2 != NULL )
 406                                 {
 407                                         name1 = da_cat_get_fullname(c1);
 408                                         name2 = da_cat_get_fullname(c2);
 409                                         retval = hb_string_utf8_compare(name1, name2);
 410                                         g_free(name2);
 411                                         g_free(name1);
 412                                 }
 413                         }
 414                         break;
 415                 default:
 416                         g_return_val_if_reached(0);
 417         }
 418
 419     return retval;
 420 }
 421
 422
 423 static void
 424 ui_pay_listview_count_cell_data_function (GtkTreeViewColumn *col,
 425                                 GtkCellRenderer *renderer,
 426                                 GtkTreeModel *model,
 427                                 GtkTreeIter *iter,
 428                                 gpointer user_data)
 429 {
 430 Payee *entry;
 431 gchar buffer[256];
 432
 433         gtk_tree_model_get(model, iter, LST_DEFPAY_DATAS, &entry, -1);
 434         if(entry->usage_count > 0)
 435         {
 436                 g_snprintf(buffer, 256-1, "%d", entry->usage_count);
 437                 g_object_set(renderer, "text", buffer, NULL);
 438         }
 439         else
 440                 g_object_set(renderer, "text", "", NULL);
 441 }
 442
 443
 444 static void
 445 ui_pay_listview_defcat_cell_data_function (GtkTreeViewColumn *col,
 446                                 GtkCellRenderer *renderer,
 447                                 GtkTreeModel *model,
 448                                 GtkTreeIter *iter,
 449                                 gpointer user_data)
 450 {
 451 Payee *entry;
 452 Category *cat;
 453 gchar *fullname;
 454
 455         gtk_tree_model_get(model, iter, LST_DEFPAY_DATAS, &entry, -1);
 456
 457         cat = da_cat_get(entry->kcat);
 458         if( cat != NULL )
 459         {
 460                 fullname = da_cat_get_fullname(cat);
 461                 g_object_set(renderer, "text", fullname, NULL);
 462                 g_free(fullname);
 463         }
 464         else
 465                 g_object_set(renderer, "text", "", NULL);
 466 }
 467
 468
 469 static void
 470 ui_pay_listview_name_cell_data_function (GtkTreeViewColumn *col,
 471                                 GtkCellRenderer *renderer,
 472                                 GtkTreeModel *model,
 473                                 GtkTreeIter *iter,
 474                                 gpointer user_data)
 475 {
 476 Payee *entry;
 477 gchar *name;
 478 #if MYDEBUG
 479 gchar *string;
 480 #endif
 481
 482         gtk_tree_model_get(model, iter, LST_DEFPAY_DATAS, &entry, -1);
 483
 484         if(entry->key == 0)
 485                 name = _("(no payee)");
 486         else
 487                 name = entry->name;
 488
 489         #if MYDEBUG
 490                 string = g_strdup_printf ("%d > %s [ft=%d]", entry->key, name, entry->filter);
 491                 g_object_set(renderer, "text", string, NULL);
 492                 g_free(string);
 493         #else
 494                 g_object_set(renderer, "text", name, NULL);
 495         #endif
 496
 497 }
 498
 499
 500 /* = = = = = = = = = = = = = = = = */
 501
 502
 503 void
 504 ui_pay_listview_add(GtkTreeView *treeview, Payee *item)
 505 {
 506 GtkTreeModel *model;
 507 GtkTreeIter     iter;
 508
 509         if( item->name != NULL )
 510         {
 511                 model = gtk_tree_view_get_model(treeview);
 512
 513                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 514                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 515                         LST_DEFPAY_TOGGLE, FALSE,
 516                         LST_DEFPAY_DATAS, item,
 517                         -1);
 518         }
 519 }
 520
 521 guint32
 522 ui_pay_listview_get_selected_key(GtkTreeView *treeview)
 523 {
 524 GtkTreeSelection *selection;
 525 GtkTreeModel             *model;
 526 GtkTreeIter                      iter;
 527
 528         selection = gtk_tree_view_get_selection(treeview);
 529         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 530         {
 531         Payee *item;
 532
 533                 gtk_tree_model_get(model, &iter, LST_DEFPAY_DATAS, &item, -1);
 534
 535                 if( item!= NULL  )
 536                         return item->key;
 537         }
 538         return 0;
 539 }
 540
 541 void
 542 ui_pay_listview_remove_selected(GtkTreeView *treeview)
 543 {
 544 GtkTreeSelection *selection;
 545 GtkTreeModel             *model;
 546 GtkTreeIter                      iter;
 547
 548         DB( g_print("ui_pay_listview_remove_selected() \n") );
 549
 550         selection = gtk_tree_view_get_selection(treeview);
 551         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 552         {
 553                 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 554         }
 555 }
 556
 557
 558 static void ui_pay_listview_populate_ghfunc(gpointer key, gpointer value, GtkTreeModel *model)
 559 {
 560 GtkTreeIter     iter;
 561 Payee *item = value;
 562
 563         //DB( g_print(" populate: %p\n", key) );
 564
 565         //gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 566         //gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 567         gtk_list_store_insert_with_values(GTK_LIST_STORE(model), &iter, -1,
 568                 LST_DEFPAY_TOGGLE       , FALSE,
 569                 LST_DEFPAY_DATAS, item,
 570                 -1);
 571 }
 572
 573 void ui_pay_listview_populate(GtkWidget *view)
 574 {
 575 GtkTreeModel *model;
 576
 577         DB( g_print("ui_pay_listview_populate \n") );
 578
 579         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 580         gtk_list_store_clear (GTK_LIST_STORE(model));
 581
 582         //g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
 583         //gtk_tree_view_set_model(GTK_TREE_VIEW(view), NULL); /* Detach model from view */
 584
 585         /* populate */
 586         g_hash_table_foreach(GLOBALS->h_pay, (GHFunc)ui_pay_listview_populate_ghfunc, model);
 587
 588         //gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); /* Re-attach model to view */
 589         //g_object_unref(model);
 590 }
 591
 592
 593 static gboolean ui_pay_listview_search_equal_func (GtkTreeModel *model,
 594                                gint column,
 595                                const gchar *key,
 596                                GtkTreeIter *iter,
 597                                gpointer search_data)
 598 {
 599   gboolean retval = TRUE;
 600   gchar *normalized_string;
 601   gchar *normalized_key;
 602   gchar *case_normalized_string = NULL;
 603   gchar *case_normalized_key = NULL;
 604   Payee *item;
 605
 606   //gtk_tree_model_get_value (model, iter, column, &value);
 607   gtk_tree_model_get(model, iter, LST_DEFPAY_DATAS, &item, -1);
 608
 609   if(item !=  NULL)
 610   {
 611           normalized_string = g_utf8_normalize (item->name, -1, G_NORMALIZE_ALL);
 612           normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
 613
 614           if (normalized_string && normalized_key)
 615                 {
 616                   case_normalized_string = g_utf8_casefold (normalized_string, -1);
 617                   case_normalized_key = g_utf8_casefold (normalized_key, -1);
 618
 619                   if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
 620                     retval = FALSE;
 621                 }
 622
 623           g_free (normalized_key);
 624           g_free (normalized_string);
 625           g_free (case_normalized_key);
 626           g_free (case_normalized_string);
 627   }
 628   return retval;
 629 }
 630
 631
 632 GtkWidget *
 633 ui_pay_listview_new(gboolean withtoggle, gboolean withcount)
 634 {
 635 GtkListStore *store;
 636 GtkWidget *treeview;
 637 GtkCellRenderer         *renderer;
 638 GtkTreeViewColumn       *column;
 639
 640         DB( g_print("ui_pay_listview_new() \n") );
 641
 642         store = gtk_list_store_new(
 643                 NUM_LST_DEFPAY,
 644                 G_TYPE_BOOLEAN,
 645                 G_TYPE_POINTER
 646                 );
 647
 648         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 649         g_object_unref(store);
 650
 651         gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (treeview), PREFS->grid_lines);
 652
 653         // column: toggle
 654         if( withtoggle == TRUE )
 655         {
 656                 renderer = gtk_cell_renderer_toggle_new ();
 657                 column = gtk_tree_view_column_new_with_attributes (_("Visible"),
 658                                                 renderer, "active", LST_DEFPAY_TOGGLE, NULL);
 659                 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 660
 661                 g_signal_connect (G_OBJECT(renderer), "toggled",
 662                             G_CALLBACK (ui_pay_listview_toggled_cb), store);
 663
 664         }
 665
 666         // column: name
 667         renderer = gtk_cell_renderer_text_new ();
 668         g_object_set(renderer,
 669                 "ellipsize", PANGO_ELLIPSIZE_END,
 670             "ellipsize-set", TRUE,
 671             NULL);
 672
 673         column = gtk_tree_view_column_new();
 674         gtk_tree_view_column_set_title(column, _("Name"));
 675         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 676         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_pay_listview_name_cell_data_function, GINT_TO_POINTER(LST_DEFPAY_DATAS), NULL);
 677         gtk_tree_view_column_set_alignment (column, 0.5);
 678         gtk_tree_view_column_set_min_width(column, HB_MINWIDTH_LIST);
 679         gtk_tree_view_column_set_sort_column_id (column, LST_DEFPAY_SORT_NAME);
 680         gtk_tree_view_column_set_resizable(column, TRUE);
 681         gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 682
 683         // column: usage
 684         if( withcount == TRUE )
 685         {
 686                 renderer = gtk_cell_renderer_text_new ();
 687                 g_object_set(renderer, "xalign", 0.5, NULL);
 688
 689                 column = gtk_tree_view_column_new();
 690                 gtk_tree_view_column_set_title(column, _("Usage"));
 691                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
 692                 gtk_tree_view_column_set_cell_data_func(column, renderer, ui_pay_listview_count_cell_data_function, GINT_TO_POINTER(LST_DEFPAY_DATAS), NULL);
 693                 gtk_tree_view_column_set_alignment (column, 0.5);
 694                 gtk_tree_view_column_set_sort_column_id (column, LST_DEFPAY_SORT_USED);
 695                 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 696         }
 697
 698         // column: category
 699         if( withtoggle == FALSE )
 700         {
 701                 renderer = gtk_cell_renderer_text_new ();
 702                 g_object_set(renderer,
 703                         "ellipsize", PANGO_ELLIPSIZE_END,
 704                         "ellipsize-set", TRUE,
 705                         NULL);
 706
 707                 column = gtk_tree_view_column_new();
 708                 gtk_tree_view_column_set_title(column, _("Default category"));
 709                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
 710                 gtk_tree_view_column_set_cell_data_func(column, renderer, ui_pay_listview_defcat_cell_data_function, GINT_TO_POINTER(LST_DEFPAY_DATAS), NULL);
 711                 gtk_tree_view_column_set_alignment (column, 0.5);
 712                 gtk_tree_view_column_set_sort_column_id (column, LST_DEFPAY_SORT_DEFCAT);
 713                 gtk_tree_view_column_set_resizable(column, TRUE);
 714                 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 715         }
 716
 717         gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview), ui_pay_listview_search_equal_func, NULL, NULL);
 718
 719         // treeview attribute
 720         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview), withcount);
 721
 722         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DEFPAY_SORT_NAME, ui_pay_listview_compare_func, GINT_TO_POINTER(LST_DEFPAY_SORT_NAME), NULL);
 723         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DEFPAY_SORT_USED, ui_pay_listview_compare_func, GINT_TO_POINTER(LST_DEFPAY_SORT_USED), NULL);
 724         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), LST_DEFPAY_SORT_DEFCAT, ui_pay_listview_compare_func, GINT_TO_POINTER(LST_DEFPAY_SORT_DEFCAT), NULL);
 725
 726         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), LST_DEFPAY_SORT_NAME, GTK_SORT_ASCENDING);
 727
 728         return treeview;
 729 }
 730
 731
 732 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 733
 734 static void
 735 ui_pay_manage_dialog_delete_unused( GtkWidget *widget, gpointer user_data)
 736 {
 737 struct ui_pay_manage_dialog_data *data = user_data;
 738 gboolean result;
 739
 740         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(widget), GTK_TYPE_WINDOW)), "inst_data");
 741
 742         DB( g_print("(ui_pay_manage_dialog) delete unused - data %p\n", data) );
 743
 744         result = ui_dialog_msg_confirm_alert(
 745                         GTK_WINDOW(data->window),
 746                         _("Delete unused payee"),
 747                         _("Are you sure you want to\npermanently delete unused payee?"),
 748                         _("_Delete")
 749                 );
 750
 751         if( result == GTK_RESPONSE_OK )
 752         {
 753         GtkTreeModel *model;
 754
 755                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_pay));
 756                 gtk_list_store_clear (GTK_LIST_STORE(model));
 757
 758                 payee_delete_unused();
 759
 760                 ui_pay_listview_populate (data->LV_pay);
 761         }
 762 }
 763
 764
 765 /**
 766  * ui_pay_manage_dialog_load_csv:
 767  *
 768  */
 769 static void
 770 ui_pay_manage_dialog_load_csv( GtkWidget *widget, gpointer user_data)
 771 {
 772 struct ui_pay_manage_dialog_data *data = user_data;
 773 gchar *filename = NULL;
 774 gchar *error;
 775
 776         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(widget), GTK_TYPE_WINDOW)), "inst_data");
 777
 778         DB( g_print("(ui_pay_manage_dialog) load csv - data %p\n", data) );
 779
 780         if( ui_file_chooser_csv(GTK_WINDOW(data->window), GTK_FILE_CHOOSER_ACTION_OPEN, &filename, NULL) == TRUE )
 781         {
 782                 DB( g_print(" + filename is %s\n", filename) );
 783
 784                 if( !payee_load_csv(filename, &error) )
 785                 {
 786                         ui_dialog_msg_infoerror(GTK_WINDOW(data->window), GTK_MESSAGE_ERROR,
 787                                         _("File format error"),
 788                                         _("The CSV file must contains the exact numbers of column,\nseparated by a semi-colon, please see the help for more details.")
 789                                         );
 790                 }
 791
 792                 g_free( filename );
 793                 ui_pay_listview_populate(data->LV_pay);
 794         }
 795 }
 796
 797 /**
 798  * ui_pay_manage_dialog_save_csv:
 799  *
 800  */
 801 static void
 802 ui_pay_manage_dialog_save_csv( GtkWidget *widget, gpointer user_data)
 803 {
 804 struct ui_pay_manage_dialog_data *data = user_data;
 805 gchar *filename = NULL;
 806
 807         DB( g_print("(ui_pay_manage_dialog) save csv\n") );
 808
 809         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 810
 811         if( ui_file_chooser_csv(GTK_WINDOW(data->window), GTK_FILE_CHOOSER_ACTION_SAVE, &filename, NULL) == TRUE )
 812         {
 813                 DB( g_print(" + filename is %s\n", filename) );
 814
 815                 payee_save_csv(filename);
 816                 g_free( filename );
 817         }
 818 }
 819
 820
 821 /**
 822  * ui_pay_manage_dialog_add:
 823  *
 824  */
 825 static void
 826 ui_pay_manage_dialog_add(GtkWidget *widget, gpointer user_data)
 827 {
 828 struct ui_pay_manage_dialog_data *data;
 829 Payee *item;
 830 gchar *name;
 831
 832         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 833         DB( g_print("(defayee) add (data=%p)\n", data) );
 834
 835         name = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_name));
 836
 837         if( payee_append_if_new(name, &item) )
 838         {
 839                 if( item ) {
 840                         ui_pay_listview_add(GTK_TREE_VIEW(data->LV_pay), item);
 841                         data->change++;
 842                 }
 843         }
 844
 845         gtk_entry_set_text(GTK_ENTRY(data->ST_name), "");
 846 }
 847
 848
 849 static void ui_pay_manage_dialog_edit_entry_cb(GtkEditable *editable, gpointer user_data)
 850 {
 851 GtkDialog *window = user_data;
 852 const gchar *buffer;
 853
 854         buffer = gtk_entry_get_text(GTK_ENTRY(editable));
 855         gtk_dialog_set_response_sensitive(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT, strlen(buffer) > 0 ? TRUE : FALSE);
 856 }
 857
 858
 859 static void ui_pay_manage_dialog_edit(GtkWidget *dowidget, gpointer user_data)
 860 {
 861 struct ui_pay_manage_dialog_data *data;
 862 GtkWidget *dialog, *content_area, *content_grid, *group_grid;
 863 GtkWidget *label, *widget;
 864 GtkWidget *ST_name, *PO_cat, *NU_mode;
 865 gint crow, row;
 866 guint32 key;
 867
 868         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(dowidget, GTK_TYPE_WINDOW)), "inst_data");
 869         DB( g_print("(defayee) modify %p\n", data) );
 870
 871         key = ui_pay_listview_get_selected_key(GTK_TREE_VIEW(data->LV_pay));
 872         if( key > 0 )
 873         {
 874         Payee *item;
 875
 876                 item = da_pay_get( key );
 877
 878                 dialog = gtk_dialog_new_with_buttons (_("Edit..."),
 879                                                     GTK_WINDOW (data->window),
 880                                                     0,
 881                                                     _("_Cancel"),
 882                                                     GTK_RESPONSE_REJECT,
 883                                                     _("_OK"),
 884                                                     GTK_RESPONSE_ACCEPT,
 885                                                     NULL);
 886
 887                 content_area = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
 888
 889                 content_grid = gtk_grid_new();
 890                 gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
 891                 gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
 892                 gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
 893                 gtk_box_pack_start (GTK_BOX (content_area), content_grid, TRUE, TRUE, 0);
 894
 895                 crow = 0;
 896                 // group :: General
 897                 group_grid = gtk_grid_new ();
 898                 gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 899                 gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 900                 gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow++, 1, 1);
 901
 902                 //label = make_label_group(_("General"));
 903                 //gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
 904
 905                 row = 1;
 906                 label = make_label_widget(_("_Name:"));
 907                 gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 908                 widget = gtk_entry_new();
 909                 ST_name = widget;
 910                 gtk_widget_set_hexpand(widget, TRUE);
 911                 gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 912
 913                 // group :: Default
 914                 group_grid = gtk_grid_new ();
 915                 gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 916                 gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 917                 gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow++, 1, 1);
 918
 919                 label = make_label_group(_("Default"));
 920                 gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 4, 1);
 921
 922                 row = 1;
 923                 label = make_label_widget(_("_Category:"));
 924                 gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
 925                 widget = ui_cat_comboboxentry_new(label);
 926                 PO_cat = widget;
 927                 gtk_widget_set_hexpand (widget, TRUE);
 928                 gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
 929
 930                 row++;
 931                 label = make_label_widget(_("Pa_yment:"));
 932                 gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
 933                 widget = make_paymode(label);
 934                 NU_mode = widget;
 935                 gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
 936
 937                 //setup
 938                 gtk_entry_set_text(GTK_ENTRY(ST_name), item->name);
 939                 gtk_widget_grab_focus (ST_name);
 940                 gtk_entry_set_activates_default (GTK_ENTRY(ST_name), TRUE);
 941
 942                 ui_cat_comboboxentry_populate(GTK_COMBO_BOX(PO_cat), GLOBALS->h_cat);
 943                 ui_cat_comboboxentry_set_active(GTK_COMBO_BOX(PO_cat), item->kcat);
 944
 945                 gtk_combo_box_set_active(GTK_COMBO_BOX(NU_mode), item->paymode);
 946
 947                 g_signal_connect (G_OBJECT (ST_name), "changed", G_CALLBACK (ui_pay_manage_dialog_edit_entry_cb), dialog);
 948
 949                 gtk_widget_show_all(content_grid);
 950
 951
 952                 gtk_dialog_set_default_response(GTK_DIALOG( dialog ), GTK_RESPONSE_ACCEPT);
 953
 954                 //wait for the user
 955                 gint result = gtk_dialog_run (GTK_DIALOG (dialog));
 956
 957                 if(result == GTK_RESPONSE_ACCEPT)
 958                 {
 959                 const gchar *name;
 960
 961                         // 1: manage renaming
 962                         name = gtk_entry_get_text(GTK_ENTRY(ST_name));
 963                         // ignore if item is empty
 964                         if (name && *name)
 965                         {
 966                                 if( payee_rename(item, name) )
 967                                 {
 968                                         //to redraw the active entry
 969                                         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_pay));
 970                                         data->change++;
 971                                 }
 972                                 else
 973                                 {
 974                                         ui_dialog_msg_infoerror(GTK_WINDOW(dialog), GTK_MESSAGE_ERROR,
 975                                                 _("Error"),
 976                                                 _("Cannot rename this Payee,\n"
 977                                                 "from '%s' to '%s',\n"
 978                                                 "this name already exists."),
 979                                                 item->name,
 980                                                 name
 981                                                 );
 982
 983                                 }
 984                         }
 985
 986                         item->kcat    = ui_cat_comboboxentry_get_key_add_new(GTK_COMBO_BOX(PO_cat));
 987                         item->paymode = gtk_combo_box_get_active(GTK_COMBO_BOX(NU_mode));
 988
 989             }
 990
 991                 // cleanup and destroy
 992                 gtk_widget_destroy (dialog);
 993         }
 994
 995 }
 996
 997
 998 static void ui_pay_manage_dialog_merge_entry_cb(GtkComboBox *widget, gpointer user_data)
 999 {
1000 GtkDialog *window = user_data;
1001 gchar *buffer;
1002
1003         buffer = (gchar *)gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (widget))));
1004         gtk_dialog_set_response_sensitive(GTK_DIALOG(window), GTK_RESPONSE_OK, strlen(buffer) > 0 ? TRUE : FALSE);
1005 }
1006
1007
1008 static void ui_pay_manage_dialog_merge(GtkWidget *widget, gpointer user_data)
1009 {
1010 struct ui_pay_manage_dialog_data *data;
1011 GtkWidget *dialog, *content, *mainvbox;
1012 GtkWidget *getwidget, *togglebutton;
1013 GtkTreeSelection *selection;
1014 GtkTreeModel *model;
1015 GtkTreeIter iter;
1016
1017         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1018         DB( g_print("(defayee) merge %p\n", data) );
1019
1020         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_pay));
1021         //if true there is a selected node
1022         if (gtk_tree_selection_get_selected(selection, &model, &iter))
1023         {
1024         Payee *srcpay;
1025         gchar *title;
1026         gchar *secondtext;
1027
1028                 gtk_tree_model_get(model, &iter, LST_DEFPAY_DATAS, &srcpay, -1);
1029
1030                 title = g_strdup_printf (
1031                         _("Merge payee '%s'"), srcpay->name);
1032
1033                 dialog = gtk_message_dialog_new (GTK_WINDOW (data->window),
1034                                                       GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1035                                                       GTK_MESSAGE_WARNING,
1036                                                       GTK_BUTTONS_NONE,
1037                                                       title,
1038                                                   NULL
1039                                                       );
1040
1041                 gtk_dialog_add_buttons (GTK_DIALOG(dialog),
1042                                 _("_Cancel"), GTK_RESPONSE_CANCEL,
1043                                 _("Merge"), GTK_RESPONSE_OK,
1044                                 NULL);
1045
1046                 gtk_dialog_set_default_response(GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
1047
1048                 content = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG (dialog));
1049                 mainvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
1050                 gtk_box_pack_start (GTK_BOX (content), mainvbox, TRUE, TRUE, 0);
1051
1052                 secondtext = _("Transactions assigned to this payee,\n"
1053                           "will be moved to the payee selected below.");
1054
1055                 g_object_set(GTK_MESSAGE_DIALOG (dialog), "secondary-text", secondtext, NULL);
1056                 g_free(title);
1057
1058                 getwidget = ui_pay_comboboxentry_new(NULL);
1059                 gtk_box_pack_start (GTK_BOX (mainvbox), getwidget, FALSE, FALSE, 0);
1060
1061                 secondtext = g_strdup_printf (
1062                         _("_Delete the payee '%s'"), srcpay->name);
1063                 togglebutton = gtk_check_button_new_with_mnemonic(secondtext);
1064                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(togglebutton), TRUE);
1065                 g_free(secondtext);
1066                 gtk_box_pack_start (GTK_BOX (mainvbox), togglebutton, FALSE, FALSE, 0);
1067
1068                 //setup
1069                 //gtk_combo_box_set_active(GTK_COMBO_BOX(getwidget), oldpos);
1070                 g_signal_connect (G_OBJECT (getwidget), "changed", G_CALLBACK (ui_pay_manage_dialog_merge_entry_cb), dialog);
1071                 gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK, FALSE);
1072
1073                 ui_pay_comboboxentry_populate_except(GTK_COMBO_BOX(getwidget), GLOBALS->h_pay, srcpay->key);
1074                 gtk_widget_grab_focus (getwidget);
1075
1076                 gtk_widget_show_all(mainvbox);
1077
1078                 //wait for the user
1079                 gint result = gtk_dialog_run (GTK_DIALOG (dialog));
1080
1081                 if(result == GTK_RESPONSE_OK)
1082                 {
1083                 GtkTreeModel *model;
1084                 Payee *payee;
1085                 guint dstpaykey;
1086
1087                         model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_pay));
1088                         gtk_list_store_clear (GTK_LIST_STORE(model));
1089
1090                         dstpaykey = ui_pay_comboboxentry_get_key_add_new(GTK_COMBO_BOX(getwidget));
1091
1092                         payee_move(srcpay->key, dstpaykey);
1093
1094
1095                         // add the new payee to listview
1096                         payee = da_pay_get(dstpaykey);
1097                         if(payee)
1098                                 ui_pay_listview_add(GTK_TREE_VIEW(data->LV_pay), payee);
1099
1100                         // delete the old payee
1101                         if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton)) )
1102                         {
1103                                 DB( g_print(" -> delete %d '%s'\n", srcpay->key, srcpay->name ) );
1104
1105                                 da_pay_remove(srcpay->key);
1106                                 ui_pay_listview_remove_selected(GTK_TREE_VIEW(data->LV_pay));
1107                         }
1108
1109
1110                         data->change++;
1111
1112                         ui_pay_listview_populate(data->LV_pay);
1113                 }
1114
1115                 // cleanup and destroy
1116                 gtk_widget_destroy (dialog);
1117         }
1118
1119 }
1120
1121
1122 /*
1123 ** delete the selected payee to our treeview and temp GList
1124 */
1125 static void ui_pay_manage_dialog_delete(GtkWidget *widget, gpointer user_data)
1126 {
1127 struct ui_pay_manage_dialog_data *data;
1128 Payee *item;
1129 guint32 key;
1130 gint result;
1131
1132
1133         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1134         DB( g_print("(ui_pay_manage_dialog) delete (data=%p)\n", data) );
1135
1136         key = ui_pay_listview_get_selected_key(GTK_TREE_VIEW(data->LV_pay));
1137         if( key > 0 )
1138         {
1139         gchar *title;
1140         gchar *secondtext = NULL;
1141
1142                 item = da_pay_get(key);
1143
1144                 title = g_strdup_printf (
1145                         _("Are you sure you want to permanently delete '%s'?"), item->name);
1146
1147                 if( item->usage_count > 0 )
1148                 {
1149                         secondtext = _("This payee is used.\n"
1150                             "Any transaction using that payee will be set to (no payee)");
1151                 }
1152
1153                 result = ui_dialog_msg_confirm_alert(
1154                                 GTK_WINDOW(data->window),
1155                                 title,
1156                                 secondtext,
1157                                 _("_Delete")
1158                         );
1159
1160                 g_free(title);
1161
1162                 if( result == GTK_RESPONSE_OK )
1163                 {
1164                         payee_move(key, 0);
1165                         ui_pay_listview_remove_selected(GTK_TREE_VIEW(data->LV_pay));
1166                         da_pay_remove(key);
1167                         data->change++;
1168                 }
1169
1170         }
1171 }
1172
1173
1174 static void ui_pay_manage_dialog_update(GtkWidget *treeview, gpointer user_data)
1175 {
1176 struct ui_pay_manage_dialog_data *data;
1177 gboolean sensitive;
1178 guint32 key;
1179
1180         DB( g_print("\n(ui_pay_manage_dialog) cursor changed\n") );
1181
1182         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW)), "inst_data");
1183
1184         key = ui_pay_listview_get_selected_key(GTK_TREE_VIEW(data->LV_pay));
1185
1186         sensitive = (key > 0) ? TRUE : FALSE;
1187         gtk_widget_set_sensitive(data->BT_edit, sensitive);
1188         gtk_widget_set_sensitive(data->BT_merge, sensitive);
1189         gtk_widget_set_sensitive(data->BT_delete, sensitive);
1190
1191 }
1192
1193
1194 /*
1195 **
1196 */
1197 static void ui_pay_manage_dialog_selection(GtkTreeSelection *treeselection, gpointer user_data)
1198 {
1199         ui_pay_manage_dialog_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
1200 }
1201
1202 static void ui_pay_manage_dialog_onRowActivated (GtkTreeView        *treeview,
1203                        GtkTreePath        *path,
1204                        GtkTreeViewColumn  *col,
1205                        gpointer            user_data)
1206 {
1207 GtkTreeModel             *model;
1208 GtkTreeIter                      iter;
1209
1210         DB( g_print("ui_pay_manage_dialog_onRowActivated()\n") );
1211
1212
1213         model = gtk_tree_view_get_model(treeview);
1214         gtk_tree_model_get_iter_first(model, &iter);
1215         if(gtk_tree_selection_iter_is_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), &iter) == FALSE)
1216         {
1217                 ui_pay_manage_dialog_edit(GTK_WIDGET(treeview), NULL);
1218         }
1219 }
1220
1221
1222 GtkWidget *ui_pay_manage_dialog (void)
1223 {
1224 struct ui_pay_manage_dialog_data data;
1225 GtkWidget *window, *content, *mainvbox, *bbox, *treeview, *scrollwin, *table;
1226 GtkWidget *menu, *menuitem, *widget, *image;
1227 gint w, h, row;
1228
1229         window = gtk_dialog_new_with_buttons (_("Manage Payees"),
1230                                             GTK_WINDOW(GLOBALS->mainwindow),
1231                                             0,
1232                                             _("_Close"),
1233                                             GTK_RESPONSE_ACCEPT,
1234                                             NULL);
1235
1236         data.window = window;
1237         data.change = 0;
1238
1239         gtk_window_set_icon_name(GTK_WINDOW (window), ICONNAME_HB_PAYEE);
1240
1241         //set a nice dialog size
1242         gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
1243         gtk_window_set_default_size (GTK_WINDOW(window), -1, h/PHI);
1244
1245
1246         //store our window private data
1247         g_object_set_data(G_OBJECT(window), "inst_data", (gpointer)&data);
1248         DB( g_print("(ui_pay_manage_dialog) window=%p, inst_data=%p\n", window, &data) );
1249
1250     g_signal_connect (window, "destroy",
1251                         G_CALLBACK (gtk_widget_destroyed), &window);
1252
1253         //window contents
1254         content = gtk_dialog_get_content_area(GTK_DIALOG (window));
1255         mainvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
1256         gtk_box_pack_start (GTK_BOX (content), mainvbox, TRUE, TRUE, 0);
1257         gtk_container_set_border_width (GTK_CONTAINER(mainvbox), SPACING_MEDIUM);
1258
1259     //our table
1260         table = gtk_grid_new ();
1261         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_SMALL);
1262         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
1263         gtk_box_pack_start (GTK_BOX (mainvbox), table, TRUE, TRUE, 0);
1264
1265         row = 0;
1266         menu = gtk_menu_new ();
1267         gtk_widget_set_halign (menu, GTK_ALIGN_END);
1268
1269         menuitem = gtk_menu_item_new_with_mnemonic (_("_Import CSV"));
1270         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1271         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_pay_manage_dialog_load_csv), &data);
1272
1273         menuitem = gtk_menu_item_new_with_mnemonic (_("E_xport CSV"));
1274         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1275         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_pay_manage_dialog_save_csv), &data);
1276
1277         menuitem = gtk_separator_menu_item_new();
1278         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1279
1280         menuitem = gtk_menu_item_new_with_mnemonic (_("_Delete unused"));
1281         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1282         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_pay_manage_dialog_delete_unused), &data);
1283
1284         gtk_widget_show_all (menu);
1285
1286         widget = gtk_menu_button_new();
1287         image = gtk_image_new_from_icon_name (ICONNAME_HB_BUTTON_MENU, GTK_ICON_SIZE_MENU);
1288
1289         //gchar *thename;
1290         //gtk_image_get_icon_name(image, &thename, NULL);
1291         //g_print("the name is %s\n", thename);
1292
1293         g_object_set (widget, "image", image, "popup", GTK_MENU(menu),  NULL);
1294         gtk_widget_set_halign (widget, GTK_ALIGN_END);
1295         gtk_grid_attach (GTK_GRID (table), widget, 1, row, 1, 1);
1296
1297         row++;
1298         data.ST_name = gtk_entry_new ();
1299         gtk_entry_set_placeholder_text(GTK_ENTRY(data.ST_name), _("new payee") );
1300         gtk_widget_set_hexpand (data.ST_name, TRUE);
1301         gtk_grid_attach (GTK_GRID (table), data.ST_name, 0, row, 2, 1);
1302
1303
1304         //list
1305         row++;
1306         scrollwin = gtk_scrolled_window_new(NULL,NULL);
1307     gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1308         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1309         gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrollwin), HB_MINHEIGHT_LIST);
1310         treeview = ui_pay_listview_new(FALSE, TRUE);
1311         data.LV_pay = treeview;
1312         gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
1313         gtk_widget_set_hexpand (scrollwin, TRUE);
1314         gtk_widget_set_vexpand (scrollwin, TRUE);
1315         gtk_grid_attach (GTK_GRID (table), scrollwin, 0, row, 2, 1);
1316
1317         row++;
1318         bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
1319         gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
1320         gtk_box_set_spacing (GTK_BOX (bbox), SPACING_SMALL);
1321         gtk_grid_attach (GTK_GRID (table), bbox, 0, row, 2, 1);
1322
1323         data.BT_edit = gtk_button_new_with_mnemonic(_("_Edit"));
1324         gtk_container_add (GTK_CONTAINER (bbox), data.BT_edit);
1325
1326         data.BT_merge = gtk_button_new_with_mnemonic(_("_Merge"));
1327         gtk_container_add (GTK_CONTAINER (bbox), data.BT_merge);
1328
1329         data.BT_delete = gtk_button_new_with_mnemonic(_("_Delete"));
1330         gtk_container_add (GTK_CONTAINER (bbox), data.BT_delete);
1331
1332
1333         //connect all our signals
1334         g_signal_connect (G_OBJECT (data.ST_name), "activate", G_CALLBACK (ui_pay_manage_dialog_add), NULL);
1335
1336         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data.LV_pay)), "changed", G_CALLBACK (ui_pay_manage_dialog_selection), NULL);
1337         g_signal_connect (GTK_TREE_VIEW(data.LV_pay), "row-activated", G_CALLBACK (ui_pay_manage_dialog_onRowActivated), NULL);
1338
1339         g_signal_connect (G_OBJECT (data.BT_edit), "clicked", G_CALLBACK (ui_pay_manage_dialog_edit), NULL);
1340         g_signal_connect (G_OBJECT (data.BT_merge), "clicked", G_CALLBACK (ui_pay_manage_dialog_merge), NULL);
1341         g_signal_connect (G_OBJECT (data.BT_delete), "clicked", G_CALLBACK (ui_pay_manage_dialog_delete), NULL);
1342
1343         //setup, init and show window
1344         payee_fill_usage();
1345         ui_pay_listview_populate(data.LV_pay);
1346         ui_pay_manage_dialog_update(data.LV_pay, NULL);
1347
1348         gtk_widget_show_all (window);
1349
1350         //wait for the user
1351         gint result = gtk_dialog_run (GTK_DIALOG (window));
1352
1353         switch (result)
1354     {
1355         case GTK_RESPONSE_ACCEPT:
1356            //do_application_specific_something ();
1357            break;
1358         default:
1359            //do_nothing_since_dialog_was_cancelled ();
1360            break;
1361     }
1362
1363         // cleanup and destroy
1364
1365         gtk_widget_destroy (window);
1366
1367         GLOBALS->changes_count += data.change;
1368
1369         return NULL;
1370 }
1371
1372
1373