Dogcows Code - chaz/homebank/blob - src/ui-payee.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
  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
 775         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(widget), GTK_TYPE_WINDOW)), "inst_data");
 776
 777         DB( g_print("(ui_pay_manage_dialog) load csv - data %p\n", data) );
 778
 779         if( ui_file_chooser_csv(GTK_WINDOW(data->window), GTK_FILE_CHOOSER_ACTION_OPEN, &filename, NULL) == TRUE )
 780         {
 781                 DB( g_print(" + filename is %s\n", filename) );
 782
 783                 payee_load_csv(filename);
 784                 //todo: add error message
 785
 786                 g_free( filename );
 787                 ui_pay_listview_populate(data->LV_pay);
 788         }
 789 }
 790
 791 /**
 792  * ui_pay_manage_dialog_save_csv:
 793  *
 794  */
 795 static void
 796 ui_pay_manage_dialog_save_csv( GtkWidget *widget, gpointer user_data)
 797 {
 798 struct ui_pay_manage_dialog_data *data = user_data;
 799 gchar *filename = NULL;
 800
 801         DB( g_print("(ui_pay_manage_dialog) save csv\n") );
 802
 803         //data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 804
 805         if( ui_file_chooser_csv(GTK_WINDOW(data->window), GTK_FILE_CHOOSER_ACTION_SAVE, &filename, NULL) == TRUE )
 806         {
 807                 DB( g_print(" + filename is %s\n", filename) );
 808
 809                 payee_save_csv(filename);
 810                 g_free( filename );
 811         }
 812 }
 813
 814
 815 /**
 816  * ui_pay_manage_dialog_add:
 817  *
 818  */
 819 static void
 820 ui_pay_manage_dialog_add(GtkWidget *widget, gpointer user_data)
 821 {
 822 struct ui_pay_manage_dialog_data *data;
 823 Payee *item;
 824 gchar *name;
 825
 826         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 827         DB( g_print("(defayee) add (data=%p)\n", data) );
 828
 829         name = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_name));
 830
 831         item = payee_append_if_new(name);
 832         if( item )
 833         {
 834                 ui_pay_listview_add(GTK_TREE_VIEW(data->LV_pay), item);
 835                 data->change++;
 836         }
 837
 838         gtk_entry_set_text(GTK_ENTRY(data->ST_name), "");
 839 }
 840
 841
 842 static void ui_pay_manage_dialog_edit_entry_cb(GtkEditable *editable, gpointer user_data)
 843 {
 844 GtkDialog *window = user_data;
 845 const gchar *buffer;
 846
 847         buffer = gtk_entry_get_text(GTK_ENTRY(editable));
 848         gtk_dialog_set_response_sensitive(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT, strlen(buffer) > 0 ? TRUE : FALSE);
 849 }
 850
 851
 852 static void ui_pay_manage_dialog_edit(GtkWidget *dowidget, gpointer user_data)
 853 {
 854 struct ui_pay_manage_dialog_data *data;
 855 GtkWidget *dialog, *content_area, *content_grid, *group_grid;
 856 GtkWidget *label, *widget;
 857 GtkWidget *ST_name, *PO_cat, *NU_mode;
 858 gint crow, row;
 859 guint32 key;
 860
 861         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(dowidget, GTK_TYPE_WINDOW)), "inst_data");
 862         DB( g_print("(defayee) modify %p\n", data) );
 863
 864         key = ui_pay_listview_get_selected_key(GTK_TREE_VIEW(data->LV_pay));
 865         if( key > 0 )
 866         {
 867         Payee *item;
 868
 869                 item = da_pay_get( key );
 870
 871                 dialog = gtk_dialog_new_with_buttons (_("Edit..."),
 872                                                     GTK_WINDOW (data->window),
 873                                                     0,
 874                                                     _("_Cancel"),
 875                                                     GTK_RESPONSE_REJECT,
 876                                                     _("_OK"),
 877                                                     GTK_RESPONSE_ACCEPT,
 878                                                     NULL);
 879
 880                 content_area = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
 881
 882                 content_grid = gtk_grid_new();
 883                 gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
 884                 gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
 885                 gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
 886                 gtk_box_pack_start (GTK_BOX (content_area), content_grid, TRUE, TRUE, 0);
 887
 888                 crow = 0;
 889                 // group :: General
 890                 group_grid = gtk_grid_new ();
 891                 gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 892                 gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 893                 gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow++, 1, 1);
 894
 895                 //label = make_label_group(_("General"));
 896                 //gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
 897
 898                 row = 1;
 899                 label = make_label_widget(_("_Name:"));
 900                 gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 901                 widget = gtk_entry_new();
 902                 ST_name = widget;
 903                 gtk_widget_set_hexpand(widget, TRUE);
 904                 gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 905
 906                 // group :: Default
 907                 group_grid = gtk_grid_new ();
 908                 gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 909                 gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 910                 gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow++, 1, 1);
 911
 912                 label = make_label_group(_("Default"));
 913                 gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 4, 1);
 914
 915                 row = 1;
 916                 label = make_label_widget(_("_Category:"));
 917                 gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
 918                 widget = ui_cat_comboboxentry_new(label);
 919                 PO_cat = widget;
 920                 gtk_widget_set_hexpand (widget, TRUE);
 921                 gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
 922
 923                 row++;
 924                 label = make_label_widget(_("Pa_yment:"));
 925                 gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 1, 1);
 926                 widget = make_paymode(label);
 927                 NU_mode = widget;
 928                 gtk_grid_attach (GTK_GRID (group_grid), widget, 1, row, 1, 1);
 929
 930                 //setup
 931                 gtk_entry_set_text(GTK_ENTRY(ST_name), item->name);
 932                 gtk_widget_grab_focus (ST_name);
 933                 gtk_entry_set_activates_default (GTK_ENTRY(ST_name), TRUE);
 934
 935                 ui_cat_comboboxentry_populate(GTK_COMBO_BOX(PO_cat), GLOBALS->h_cat);
 936                 ui_cat_comboboxentry_set_active(GTK_COMBO_BOX(PO_cat), item->kcat);
 937
 938                 gtk_combo_box_set_active(GTK_COMBO_BOX(NU_mode), item->paymode);
 939
 940                 g_signal_connect (G_OBJECT (ST_name), "changed", G_CALLBACK (ui_pay_manage_dialog_edit_entry_cb), dialog);
 941
 942                 gtk_widget_show_all(content_grid);
 943
 944
 945                 gtk_dialog_set_default_response(GTK_DIALOG( dialog ), GTK_RESPONSE_ACCEPT);
 946
 947                 //wait for the user
 948                 gint result = gtk_dialog_run (GTK_DIALOG (dialog));
 949
 950                 if(result == GTK_RESPONSE_ACCEPT)
 951                 {
 952                 const gchar *name;
 953
 954                         // 1: manage renaming
 955                         name = gtk_entry_get_text(GTK_ENTRY(ST_name));
 956                         // ignore if item is empty
 957                         if (name && *name)
 958                         {
 959                                 if( payee_rename(item, name) )
 960                                 {
 961                                         //to redraw the active entry
 962                                         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_pay));
 963                                         data->change++;
 964                                 }
 965                                 else
 966                                 {
 967                                         ui_dialog_msg_infoerror(GTK_WINDOW(dialog), GTK_MESSAGE_ERROR,
 968                                                 _("Error"),
 969                                                 _("Cannot rename this Payee,\n"
 970                                                 "from '%s' to '%s',\n"
 971                                                 "this name already exists."),
 972                                                 item->name,
 973                                                 name
 974                                                 );
 975
 976                                 }
 977                         }
 978
 979                         item->kcat    = ui_cat_comboboxentry_get_key_add_new(GTK_COMBO_BOX(PO_cat));
 980                         item->paymode = gtk_combo_box_get_active(GTK_COMBO_BOX(NU_mode));
 981
 982             }
 983
 984                 // cleanup and destroy
 985                 gtk_widget_destroy (dialog);
 986         }
 987
 988 }
 989
 990
 991 static void ui_pay_manage_dialog_merge_entry_cb(GtkComboBox *widget, gpointer user_data)
 992 {
 993 GtkDialog *window = user_data;
 994 gchar *buffer;
 995
 996         buffer = (gchar *)gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (widget))));
 997         gtk_dialog_set_response_sensitive(GTK_DIALOG(window), GTK_RESPONSE_OK, strlen(buffer) > 0 ? TRUE : FALSE);
 998 }
 999
1000
1001 static void ui_pay_manage_dialog_merge(GtkWidget *widget, gpointer user_data)
1002 {
1003 struct ui_pay_manage_dialog_data *data;
1004 GtkWidget *dialog, *content, *mainvbox;
1005 GtkWidget *getwidget, *togglebutton;
1006 GtkTreeSelection *selection;
1007 GtkTreeModel *model;
1008 GtkTreeIter iter;
1009
1010         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1011         DB( g_print("(defayee) merge %p\n", data) );
1012
1013         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_pay));
1014         //if true there is a selected node
1015         if (gtk_tree_selection_get_selected(selection, &model, &iter))
1016         {
1017         Payee *srcpay;
1018         gchar *title;
1019         gchar *secondtext;
1020
1021                 gtk_tree_model_get(model, &iter, LST_DEFPAY_DATAS, &srcpay, -1);
1022
1023                 title = g_strdup_printf (
1024                         _("Merge payee '%s'"), srcpay->name);
1025
1026                 dialog = gtk_message_dialog_new (GTK_WINDOW (data->window),
1027                                                       GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1028                                                       GTK_MESSAGE_WARNING,
1029                                                       GTK_BUTTONS_NONE,
1030                                                       title,
1031                                                   NULL
1032                                                       );
1033
1034                 gtk_dialog_add_buttons (GTK_DIALOG(dialog),
1035                                 _("_Cancel"), GTK_RESPONSE_CANCEL,
1036                                 _("Merge"), GTK_RESPONSE_OK,
1037                                 NULL);
1038
1039                 gtk_dialog_set_default_response(GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
1040
1041                 content = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG (dialog));
1042                 mainvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
1043                 gtk_box_pack_start (GTK_BOX (content), mainvbox, TRUE, TRUE, 0);
1044
1045                 secondtext = _("Transactions assigned to this payee,\n"
1046                           "will be moved to the payee selected below.");
1047
1048                 g_object_set(GTK_MESSAGE_DIALOG (dialog), "secondary-text", secondtext, NULL);
1049                 g_free(title);
1050
1051                 getwidget = ui_pay_comboboxentry_new(NULL);
1052                 gtk_box_pack_start (GTK_BOX (mainvbox), getwidget, FALSE, FALSE, 0);
1053
1054                 secondtext = g_strdup_printf (
1055                         _("_Delete the payee '%s'"), srcpay->name);
1056                 togglebutton = gtk_check_button_new_with_mnemonic(secondtext);
1057                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(togglebutton), TRUE);
1058                 g_free(secondtext);
1059                 gtk_box_pack_start (GTK_BOX (mainvbox), togglebutton, FALSE, FALSE, 0);
1060
1061                 //setup
1062                 //gtk_combo_box_set_active(GTK_COMBO_BOX(getwidget), oldpos);
1063                 g_signal_connect (G_OBJECT (getwidget), "changed", G_CALLBACK (ui_pay_manage_dialog_merge_entry_cb), dialog);
1064                 gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK, FALSE);
1065
1066                 ui_pay_comboboxentry_populate_except(GTK_COMBO_BOX(getwidget), GLOBALS->h_pay, srcpay->key);
1067                 gtk_widget_grab_focus (getwidget);
1068
1069                 gtk_widget_show_all(mainvbox);
1070
1071                 //wait for the user
1072                 gint result = gtk_dialog_run (GTK_DIALOG (dialog));
1073
1074                 if(result == GTK_RESPONSE_OK)
1075                 {
1076                 GtkTreeModel *model;
1077                 Payee *payee;
1078                 guint dstpaykey;
1079
1080                         model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_pay));
1081                         gtk_list_store_clear (GTK_LIST_STORE(model));
1082
1083                         dstpaykey = ui_pay_comboboxentry_get_key_add_new(GTK_COMBO_BOX(getwidget));
1084
1085                         payee_move(srcpay->key, dstpaykey);
1086
1087
1088                         // add the new payee to listview
1089                         payee = da_pay_get(dstpaykey);
1090                         if(payee)
1091                                 ui_pay_listview_add(GTK_TREE_VIEW(data->LV_pay), payee);
1092
1093                         // delete the old payee
1094                         if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton)) )
1095                         {
1096                                 DB( g_print(" -> delete %d '%s'\n", srcpay->key, srcpay->name ) );
1097
1098                                 da_pay_remove(srcpay->key);
1099                                 ui_pay_listview_remove_selected(GTK_TREE_VIEW(data->LV_pay));
1100                         }
1101
1102
1103                         data->change++;
1104
1105                         ui_pay_listview_populate(data->LV_pay);
1106                 }
1107
1108                 // cleanup and destroy
1109                 gtk_widget_destroy (dialog);
1110         }
1111
1112 }
1113
1114
1115 /*
1116 ** delete the selected payee to our treeview and temp GList
1117 */
1118 static void ui_pay_manage_dialog_delete(GtkWidget *widget, gpointer user_data)
1119 {
1120 struct ui_pay_manage_dialog_data *data;
1121 Payee *item;
1122 guint32 key;
1123 gint result;
1124
1125
1126         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
1127         DB( g_print("(ui_pay_manage_dialog) delete (data=%p)\n", data) );
1128
1129         key = ui_pay_listview_get_selected_key(GTK_TREE_VIEW(data->LV_pay));
1130         if( key > 0 )
1131         {
1132         gchar *title;
1133         gchar *secondtext = NULL;
1134
1135                 item = da_pay_get(key);
1136
1137                 title = g_strdup_printf (
1138                         _("Are you sure you want to permanently delete '%s'?"), item->name);
1139
1140                 if( item->usage_count > 0 )
1141                 {
1142                         secondtext = _("This payee is used.\n"
1143                             "Any transaction using that payee will be set to (no payee)");
1144                 }
1145
1146                 result = ui_dialog_msg_confirm_alert(
1147                                 GTK_WINDOW(data->window),
1148                                 title,
1149                                 secondtext,
1150                                 _("_Delete")
1151                         );
1152
1153                 g_free(title);
1154
1155                 if( result == GTK_RESPONSE_OK )
1156                 {
1157                         payee_move(key, 0);
1158                         ui_pay_listview_remove_selected(GTK_TREE_VIEW(data->LV_pay));
1159                         da_pay_remove(key);
1160                         data->change++;
1161                 }
1162
1163         }
1164 }
1165
1166
1167 static void ui_pay_manage_dialog_update(GtkWidget *treeview, gpointer user_data)
1168 {
1169 struct ui_pay_manage_dialog_data *data;
1170 gboolean sensitive;
1171 guint32 key;
1172
1173         DB( g_print("\n(ui_pay_manage_dialog) cursor changed\n") );
1174
1175         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW)), "inst_data");
1176
1177         key = ui_pay_listview_get_selected_key(GTK_TREE_VIEW(data->LV_pay));
1178
1179         sensitive = (key > 0) ? TRUE : FALSE;
1180         gtk_widget_set_sensitive(data->BT_edit, sensitive);
1181         gtk_widget_set_sensitive(data->BT_merge, sensitive);
1182         gtk_widget_set_sensitive(data->BT_delete, sensitive);
1183
1184 }
1185
1186
1187 /*
1188 **
1189 */
1190 static void ui_pay_manage_dialog_selection(GtkTreeSelection *treeselection, gpointer user_data)
1191 {
1192         ui_pay_manage_dialog_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
1193 }
1194
1195 static void ui_pay_manage_dialog_onRowActivated (GtkTreeView        *treeview,
1196                        GtkTreePath        *path,
1197                        GtkTreeViewColumn  *col,
1198                        gpointer            user_data)
1199 {
1200 GtkTreeModel             *model;
1201 GtkTreeIter                      iter;
1202
1203         DB( g_print("ui_pay_manage_dialog_onRowActivated()\n") );
1204
1205
1206         model = gtk_tree_view_get_model(treeview);
1207         gtk_tree_model_get_iter_first(model, &iter);
1208         if(gtk_tree_selection_iter_is_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), &iter) == FALSE)
1209         {
1210                 ui_pay_manage_dialog_edit(GTK_WIDGET(treeview), NULL);
1211         }
1212 }
1213
1214
1215 GtkWidget *ui_pay_manage_dialog (void)
1216 {
1217 struct ui_pay_manage_dialog_data data;
1218 GtkWidget *window, *content, *mainvbox, *bbox, *treeview, *scrollwin, *table;
1219 GtkWidget *menu, *menuitem, *widget, *image;
1220 gint w, h, row;
1221
1222         window = gtk_dialog_new_with_buttons (_("Manage Payees"),
1223                                             GTK_WINDOW(GLOBALS->mainwindow),
1224                                             0,
1225                                             _("_Close"),
1226                                             GTK_RESPONSE_ACCEPT,
1227                                             NULL);
1228
1229         data.window = window;
1230         data.change = 0;
1231
1232         gtk_window_set_icon_name(GTK_WINDOW (window), ICONNAME_HB_PAYEE);
1233
1234         //set a nice dialog size
1235         gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
1236         gtk_window_set_default_size (GTK_WINDOW(window), -1, h/PHI);
1237
1238
1239         //store our window private data
1240         g_object_set_data(G_OBJECT(window), "inst_data", (gpointer)&data);
1241         DB( g_print("(ui_pay_manage_dialog) window=%p, inst_data=%p\n", window, &data) );
1242
1243     g_signal_connect (window, "destroy",
1244                         G_CALLBACK (gtk_widget_destroyed), &window);
1245
1246         //window contents
1247         content = gtk_dialog_get_content_area(GTK_DIALOG (window));
1248         mainvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
1249         gtk_box_pack_start (GTK_BOX (content), mainvbox, TRUE, TRUE, 0);
1250         gtk_container_set_border_width (GTK_CONTAINER(mainvbox), SPACING_MEDIUM);
1251
1252     //our table
1253         table = gtk_grid_new ();
1254         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_SMALL);
1255         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
1256         gtk_box_pack_start (GTK_BOX (mainvbox), table, TRUE, TRUE, 0);
1257
1258         row = 0;
1259         menu = gtk_menu_new ();
1260         gtk_widget_set_halign (menu, GTK_ALIGN_END);
1261
1262         menuitem = gtk_menu_item_new_with_mnemonic (_("_Import CSV"));
1263         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1264         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_pay_manage_dialog_load_csv), &data);
1265
1266         menuitem = gtk_menu_item_new_with_mnemonic (_("E_xport CSV"));
1267         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1268         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_pay_manage_dialog_save_csv), &data);
1269
1270         menuitem = gtk_separator_menu_item_new();
1271         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1272
1273         menuitem = gtk_menu_item_new_with_mnemonic (_("_Delete unused"));
1274         gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1275         g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (ui_pay_manage_dialog_delete_unused), &data);
1276
1277         gtk_widget_show_all (menu);
1278
1279         widget = gtk_menu_button_new();
1280         image = gtk_image_new_from_icon_name (ICONNAME_HB_BUTTON_MENU, GTK_ICON_SIZE_MENU);
1281
1282         //gchar *thename;
1283         //gtk_image_get_icon_name(image, &thename, NULL);
1284         //g_print("the name is %s\n", thename);
1285
1286         g_object_set (widget, "image", image, "popup", GTK_MENU(menu),  NULL);
1287         gtk_widget_set_halign (widget, GTK_ALIGN_END);
1288         gtk_grid_attach (GTK_GRID (table), widget, 1, row, 1, 1);
1289
1290         row++;
1291         data.ST_name = gtk_entry_new ();
1292         gtk_entry_set_placeholder_text(GTK_ENTRY(data.ST_name), _("new payee") );
1293         gtk_widget_set_hexpand (data.ST_name, TRUE);
1294         gtk_grid_attach (GTK_GRID (table), data.ST_name, 0, row, 2, 1);
1295
1296
1297         //list
1298         row++;
1299         scrollwin = gtk_scrolled_window_new(NULL,NULL);
1300     gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
1301         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1302         gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrollwin), HB_MINHEIGHT_LIST);
1303         treeview = ui_pay_listview_new(FALSE, TRUE);
1304         data.LV_pay = treeview;
1305         gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
1306         gtk_widget_set_hexpand (scrollwin, TRUE);
1307         gtk_widget_set_vexpand (scrollwin, TRUE);
1308         gtk_grid_attach (GTK_GRID (table), scrollwin, 0, row, 2, 1);
1309
1310         row++;
1311         bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
1312         gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
1313         gtk_box_set_spacing (GTK_BOX (bbox), SPACING_SMALL);
1314         gtk_grid_attach (GTK_GRID (table), bbox, 0, row, 2, 1);
1315
1316         data.BT_edit = gtk_button_new_with_mnemonic(_("_Edit"));
1317         gtk_container_add (GTK_CONTAINER (bbox), data.BT_edit);
1318
1319         data.BT_merge = gtk_button_new_with_mnemonic(_("_Merge"));
1320         gtk_container_add (GTK_CONTAINER (bbox), data.BT_merge);
1321
1322         data.BT_delete = gtk_button_new_with_mnemonic(_("_Delete"));
1323         gtk_container_add (GTK_CONTAINER (bbox), data.BT_delete);
1324
1325
1326         //connect all our signals
1327         g_signal_connect (G_OBJECT (data.ST_name), "activate", G_CALLBACK (ui_pay_manage_dialog_add), NULL);
1328
1329         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data.LV_pay)), "changed", G_CALLBACK (ui_pay_manage_dialog_selection), NULL);
1330         g_signal_connect (GTK_TREE_VIEW(data.LV_pay), "row-activated", G_CALLBACK (ui_pay_manage_dialog_onRowActivated), NULL);
1331
1332         g_signal_connect (G_OBJECT (data.BT_edit), "clicked", G_CALLBACK (ui_pay_manage_dialog_edit), NULL);
1333         g_signal_connect (G_OBJECT (data.BT_merge), "clicked", G_CALLBACK (ui_pay_manage_dialog_merge), NULL);
1334         g_signal_connect (G_OBJECT (data.BT_delete), "clicked", G_CALLBACK (ui_pay_manage_dialog_delete), NULL);
1335
1336         //setup, init and show window
1337         payee_fill_usage();
1338         ui_pay_listview_populate(data.LV_pay);
1339         ui_pay_manage_dialog_update(data.LV_pay, NULL);
1340
1341         gtk_widget_show_all (window);
1342
1343         //wait for the user
1344         gint result = gtk_dialog_run (GTK_DIALOG (window));
1345
1346         switch (result)
1347     {
1348         case GTK_RESPONSE_ACCEPT:
1349            //do_application_specific_something ();
1350            break;
1351         default:
1352            //do_nothing_since_dialog_was_cancelled ();
1353            break;
1354     }
1355
1356         // cleanup and destroy
1357
1358         gtk_widget_destroy (window);
1359
1360         GLOBALS->changes_count += data.change;
1361
1362         return NULL;
1363 }
1364
1365
1366