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

   1 /*  HomeBank -- Free, easy, personal ruleing for everyone.
   2  *  Copyright (C) 1995-2018 Maxime DOYEN
   3  *
   4  *  This file is part of HomeBank.
   5  *
   6  *  HomeBank is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  HomeBank is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "homebank.h"
  21
  22 #include "ui-assign.h"
  23
  24 #include "ui-category.h"
  25 #include "ui-payee.h"
  26
  27 #define MYDEBUG 0
  28
  29 #if MYDEBUG
  30 #define DB(x) (x);
  31 #else
  32 #define DB(x);
  33 #endif
  34
  35 /* our global datas */
  36 extern struct HomeBank *GLOBALS;
  37 extern struct Preferences *PREFS;
  38
  39 gchar *CYA_ASG_FIELD[] = {
  40         N_("Memo"),
  41         N_("Payee"),
  42         NULL
  43 };
  44
  45 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  46
  47
  48 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  49
  50
  51 static void
  52 ui_asg_listview_toggled_cb (GtkCellRendererToggle *cell,
  53                gchar                 *path_str,
  54                gpointer               data)
  55 {
  56   GtkTreeModel *model = (GtkTreeModel *)data;
  57   GtkTreeIter  iter;
  58   GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
  59   gboolean fixed;
  60
  61   /* get toggled iter */
  62   gtk_tree_model_get_iter (model, &iter, path);
  63   gtk_tree_model_get (model, &iter, LST_DEFASG_TOGGLE, &fixed, -1);
  64
  65   /* do something with the value */
  66   fixed ^= 1;
  67
  68   /* set new value */
  69   gtk_list_store_set (GTK_LIST_STORE (model), &iter, LST_DEFASG_TOGGLE, fixed, -1);
  70
  71   /* clean up */
  72   gtk_tree_path_free (path);
  73 }
  74
  75 static gint
  76 ui_asg_listview_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
  77 {
  78 Assign *entry1, *entry2;
  79
  80     gtk_tree_model_get(model, a, LST_DEFASG_DATAS, &entry1, -1);
  81     gtk_tree_model_get(model, b, LST_DEFASG_DATAS, &entry2, -1);
  82
  83     return hb_string_utf8_compare(entry1->text, entry2->text);
  84 }
  85
  86 static void
  87 ui_asg_listview_name_cell_data_function (GtkTreeViewColumn *col,
  88                                 GtkCellRenderer *renderer,
  89                                 GtkTreeModel *model,
  90                                 GtkTreeIter *iter,
  91                                 gpointer user_data)
  92 {
  93 Assign *entry;
  94 gchar *name;
  95 #if MYDEBUG
  96 gchar *string;
  97 #endif
  98
  99         gtk_tree_model_get(model, iter, LST_DEFASG_DATAS, &entry, -1);
 100         if(entry->text == NULL)
 101                 name = _("(none)");             // can never occurs also
 102         else
 103                 name = entry->text;
 104
 105         #if MYDEBUG
 106                 string = g_strdup_printf ("[%d] %s", entry->key, name );
 107                 g_object_set(renderer, "text", string, NULL);
 108                 g_free(string);
 109         #else
 110                 g_object_set(renderer, "text", name, NULL);
 111         #endif
 112
 113 }
 114
 115
 116
 117 /* = = = = = = = = = = = = = = = = */
 118
 119 /**
 120  * rul_list_add:
 121  *
 122  * Add a single element (useful for dynamics add)
 123  *
 124  * Return value: --
 125  *
 126  */
 127 void
 128 ui_asg_listview_add(GtkTreeView *treeview, Assign *item)
 129 {
 130         if( item->text != NULL )
 131         {
 132         GtkTreeModel *model;
 133         GtkTreeIter     iter;
 134
 135                 model = gtk_tree_view_get_model(treeview);
 136
 137                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 138                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 139                         LST_DEFASG_TOGGLE, FALSE,
 140                         LST_DEFASG_DATAS, item,
 141                         -1);
 142
 143                 gtk_tree_selection_select_iter (gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), &iter);
 144
 145         }
 146 }
 147
 148 guint32
 149 ui_asg_listview_get_selected_key(GtkTreeView *treeview)
 150 {
 151 GtkTreeSelection *selection;
 152 GtkTreeModel             *model;
 153 GtkTreeIter                      iter;
 154
 155         selection = gtk_tree_view_get_selection(treeview);
 156         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 157         {
 158         Assign *item;
 159
 160                 gtk_tree_model_get(model, &iter, LST_DEFASG_DATAS, &item, -1);
 161
 162                 if( item!= NULL  )
 163                         return item->key;
 164         }
 165         return 0;
 166 }
 167
 168 void
 169 ui_asg_listview_remove_selected(GtkTreeView *treeview)
 170 {
 171 GtkTreeSelection *selection;
 172 GtkTreeModel             *model;
 173 GtkTreeIter                      iter;
 174
 175         selection = gtk_tree_view_get_selection(treeview);
 176         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 177         {
 178                 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 179         }
 180 }
 181
 182 /*
 183 static gint ui_asg_glist_compare_func(Assign *a, Assign *b)
 184 {
 185         return 0; //((gint)a->pos - b->pos);
 186 }
 187 */
 188
 189 void ui_asg_listview_populate(GtkWidget *view)
 190 {
 191 GtkTreeModel *model;
 192 GtkTreeIter     iter;
 193 GList *lrul, *list;
 194
 195         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 196
 197         gtk_list_store_clear (GTK_LIST_STORE(model));
 198
 199         g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
 200         gtk_tree_view_set_model(GTK_TREE_VIEW(view), NULL); /* Detach model from view */
 201
 202         /* populate */
 203         //g_hash_table_foreach(GLOBALS->h_rul, (GHFunc)ui_asg_listview_populate_ghfunc, model);
 204         lrul = list = g_hash_table_get_values(GLOBALS->h_rul);
 205
 206         //list = g_list_sort(list, (GCompareFunc)ui_asg_glist_compare_func);
 207         while (list != NULL)
 208         {
 209         Assign *item = list->data;
 210
 211                 DB( g_print(" populate: %d\n", item->key) );
 212
 213                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 214                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 215                         LST_DEFASG_TOGGLE       , FALSE,
 216                         LST_DEFASG_DATAS, item,
 217                         -1);
 218
 219                 list = g_list_next(list);
 220         }
 221         g_list_free(lrul);
 222
 223         gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); /* Re-attach model to view */
 224         g_object_unref(model);
 225 }
 226
 227
 228 GtkWidget *
 229 ui_asg_listview_new(gboolean withtoggle)
 230 {
 231 GtkListStore *store;
 232 GtkWidget *treeview;
 233 GtkCellRenderer         *renderer;
 234 GtkTreeViewColumn       *column;
 235
 236         // create list store
 237         store = gtk_list_store_new(NUM_LST_DEFASG,
 238                 G_TYPE_BOOLEAN,
 239                 G_TYPE_POINTER
 240                 );
 241
 242         // treeview
 243         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 244         g_object_unref(store);
 245
 246         gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (treeview), PREFS->grid_lines);
 247
 248         // column 1: toggle
 249         if( withtoggle == TRUE )
 250         {
 251                 renderer = gtk_cell_renderer_toggle_new ();
 252                 column = gtk_tree_view_column_new_with_attributes (_("Visible"),
 253                                                              renderer,
 254                                                              "active", LST_DEFASG_TOGGLE,
 255                                                              NULL);
 256                 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 257
 258                 g_signal_connect (renderer, "toggled",
 259                             G_CALLBACK (ui_asg_listview_toggled_cb), store);
 260
 261         }
 262
 263         // column 2: name
 264         renderer = gtk_cell_renderer_text_new ();
 265         g_object_set(renderer,
 266                 "ellipsize", PANGO_ELLIPSIZE_END,
 267                 "ellipsize-set", TRUE,
 268                 NULL);
 269
 270         column = gtk_tree_view_column_new();
 271         gtk_tree_view_column_set_title(column, _("Text"));
 272         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 273         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_asg_listview_name_cell_data_function, GINT_TO_POINTER(LST_DEFASG_DATAS), NULL);
 274         gtk_tree_view_column_set_alignment (column, 0.5);
 275         gtk_tree_view_column_set_resizable(column, TRUE);
 276         gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 277
 278         // treeviewattribute
 279         //gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview), FALSE);
 280         gtk_tree_view_set_reorderable (GTK_TREE_VIEW(treeview), TRUE);
 281
 282         gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), ui_asg_listview_compare_func, NULL, NULL);
 283         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 284
 285         return treeview;
 286 }
 287
 288 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 289 //todo move this
 290 static gboolean
 291 assign_rename(Assign *item, gchar *newname)
 292 {
 293 Assign *existitem;
 294
 295         existitem = da_asg_get_by_name(newname);
 296         if( existitem == NULL )
 297         {
 298                 g_free(item->text);
 299                 item->text = g_strdup(newname);
 300                 return TRUE;
 301         }
 302
 303         return FALSE;
 304 }
 305
 306
 307
 308 static void ui_asg_manage_getlast(struct ui_asg_manage_data *data)
 309 {
 310 Assign *item;
 311 gint active;
 312
 313         DB( g_print("\n(ui_asg_manage_getlast)\n") );
 314
 315         DB( g_print(" -> for assign id=%d\n", data->lastkey) );
 316
 317         item = da_asg_get(data->lastkey);
 318         if(item != NULL)
 319         {
 320                 data->change++;
 321
 322                 item->field = radio_get_active(GTK_CONTAINER(data->CY_field));
 323
 324                 /*txt = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_text));
 325                 if (txt && *txt)
 326                 {
 327                         bool = assign_rename(item, txt);
 328                         if(bool)
 329                         {
 330                                 gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_rul));
 331                         }
 332                         else
 333                         {
 334                                 gtk_entry_set_text(GTK_ENTRY(data->ST_text), item->text);
 335                         }
 336                 }*/
 337
 338                 item->flags = 0;
 339
 340                 active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_exact));
 341                 if(active == 1) item->flags |= ASGF_EXACT;
 342
 343                 active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->CM_re));
 344                 if(active == 1) item->flags |= ASGF_REGEX;
 345
 346                 active = radio_get_active (GTK_CONTAINER(data->RA_pay));
 347                 if(active == 1) item->flags |= ASGF_DOPAY;
 348                 else
 349                         if(active == 2) item->flags |= ASGF_OVWPAY;
 350
 351                 active = radio_get_active (GTK_CONTAINER(data->RA_cat));
 352                 if(active == 1) item->flags |= ASGF_DOCAT;
 353                 else
 354                         if(active == 2) item->flags |= ASGF_OVWCAT;
 355
 356                 active = radio_get_active (GTK_CONTAINER(data->RA_mod));
 357                 if(active == 1) item->flags |= ASGF_DOMOD;
 358                 else
 359                         if(active == 2) item->flags |= ASGF_OVWMOD;
 360
 361                 item->kcat    = ui_cat_comboboxentry_get_key_add_new(GTK_COMBO_BOX(data->PO_cat));
 362                 item->kpay    = ui_pay_comboboxentry_get_key_add_new(GTK_COMBO_BOX(data->PO_pay));
 363                 item->paymode = gtk_combo_box_get_active(GTK_COMBO_BOX(data->NU_mod));
 364
 365         }
 366
 367 }
 368
 369
 370
 371 /*
 372 ** set widgets contents from the selected assign
 373 */
 374 static void ui_asg_manage_set(GtkWidget *widget, gpointer user_data)
 375 {
 376 struct ui_asg_manage_data *data;
 377 GtkTreeSelection *selection;
 378 GtkTreeModel             *model;
 379 GtkTreeIter                      iter;
 380 Assign *item;
 381 gint active;
 382
 383         DB( g_print("\n(ui_asg_manage_set)\n") );
 384
 385         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 386
 387         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_rul));
 388         //if true there is a selected node
 389         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 390         {
 391                 gtk_tree_model_get(model, &iter, LST_DEFASG_DATAS, &item, -1);
 392
 393                 DB( g_print(" -> set rul id=%d\n", item->key) );
 394
 395                 radio_set_active(GTK_CONTAINER(data->CY_field), item->field);
 396
 397                 gtk_entry_set_text(GTK_ENTRY(data->ST_text), item->text);
 398
 399                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_exact), (item->flags & ASGF_EXACT) ? 1 : 0);
 400                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->CM_re), (item->flags & ASGF_REGEX) ? 1 : 0);
 401
 402                 active = 0;
 403                 if(item->flags & ASGF_DOPAY) active = 1;
 404                 else if(item->flags & ASGF_OVWPAY) active = 2;
 405                 radio_set_active(GTK_CONTAINER(data->RA_pay), active);
 406                 ui_pay_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_pay), item->kpay);
 407
 408                 active = 0;
 409                 if(item->flags & ASGF_DOCAT) active = 1;
 410                 else if(item->flags & ASGF_OVWCAT) active = 2;
 411                 radio_set_active(GTK_CONTAINER(data->RA_cat), active);
 412                 ui_cat_comboboxentry_set_active(GTK_COMBO_BOX(data->PO_cat), item->kcat);
 413
 414                 active = 0;
 415                 if(item->flags & ASGF_DOMOD) active = 1;
 416                 else if(item->flags & ASGF_OVWMOD) active = 2;
 417                 radio_set_active(GTK_CONTAINER(data->RA_mod), active);
 418                 gtk_combo_box_set_active(GTK_COMBO_BOX(data->NU_mod), item->paymode);
 419
 420         }
 421
 422 }
 423
 424 /*
 425 static gboolean ui_asg_manage_focus_out(GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
 426 {
 427         ui_asg_manage_get(widget, user_data);
 428         return FALSE;
 429 }
 430 */
 431
 432 static void ui_asg_manage_update_assignments(GtkWidget *widget, gpointer user_data)
 433 {
 434 struct ui_asg_manage_data *data;
 435 gboolean sensitive;
 436
 437         DB( g_print("\n(ui_asg_manage_update_assignments)\n") );
 438
 439         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 440
 441         sensitive = (radio_get_active (GTK_CONTAINER(data->RA_pay)) > 0) ? TRUE : FALSE;
 442         gtk_widget_set_sensitive(data->LB_pay, sensitive);
 443         gtk_widget_set_sensitive(data->PO_pay, sensitive);
 444
 445         sensitive = (radio_get_active (GTK_CONTAINER(data->RA_cat)) > 0) ? TRUE : FALSE;
 446         gtk_widget_set_sensitive(data->LB_cat, sensitive);
 447         gtk_widget_set_sensitive(data->PO_cat, sensitive);
 448
 449         sensitive = (radio_get_active (GTK_CONTAINER(data->RA_mod)) > 0) ? TRUE : FALSE;
 450         gtk_widget_set_sensitive(data->LB_mod, sensitive);
 451         gtk_widget_set_sensitive(data->NU_mod, sensitive);
 452
 453 }
 454
 455 /*
 456 ** update the widgets status and contents from action/selection value
 457 */
 458 static void ui_asg_manage_update(GtkWidget *widget, gpointer user_data)
 459 {
 460 struct ui_asg_manage_data *data;
 461 GtkTreeModel             *model;
 462 GtkTreeIter                      iter;
 463 gboolean selected, sensitive;
 464 guint32 key;
 465 //gboolean is_new;
 466
 467         DB( g_print("\n(ui_asg_manage_update)\n") );
 468
 469         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 470         //window = gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW);
 471         //DB( g_print("(defpayee) widget=%08lx, window=%08lx, inst_data=%08lx\n", treeview, window, data) );
 472
 473         //if true there is a selected node
 474         selected = gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_rul)), &model, &iter);
 475         key = ui_asg_listview_get_selected_key(GTK_TREE_VIEW(data->LV_rul));
 476
 477         DB( g_print(" -> selected = %d  action = %d key = %d\n", selected, data->action, key) );
 478
 479
 480         sensitive = (selected == TRUE) ? TRUE : FALSE;
 481         gtk_widget_set_sensitive(data->GR_condition, sensitive);
 482         gtk_widget_set_sensitive(data->GR_pay, sensitive);
 483         gtk_widget_set_sensitive(data->GR_cat, sensitive);
 484         gtk_widget_set_sensitive(data->GR_mod, sensitive);
 485
 486         //sensitive = (data->action == 0) ? TRUE : FALSE;
 487         //gtk_widget_set_sensitive(data->LV_rul, sensitive);
 488         //gtk_widget_set_sensitive(data->BT_add, sensitive);
 489
 490         sensitive = (selected == TRUE && data->action == 0) ? TRUE : FALSE;
 491         //gtk_widget_set_sensitive(data->BT_mod, sensitive);
 492         gtk_widget_set_sensitive(data->BT_rem, sensitive);
 493
 494         if(selected)
 495         {
 496                 if(key != data->lastkey)
 497                 {
 498                         DB( g_print(" -> should first do a get for assign %d\n", data->lastkey) );
 499                         ui_asg_manage_getlast(data);
 500                 }
 501
 502                 ui_asg_manage_set(widget, NULL);
 503                 ui_asg_manage_update_assignments(widget, NULL);
 504         }
 505
 506         data->lastkey = key;
 507
 508 }
 509
 510
 511 /*
 512 ** add an empty new assign to our temp GList and treeview
 513 */
 514 static void ui_asg_manage_add(GtkWidget *widget, gpointer user_data)
 515 {
 516 struct ui_asg_manage_data *data;
 517 Assign *item;
 518
 519         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 520         DB( g_print("\n(ui_asg_manage_add) (data=%x)\n", (guint)data) );
 521
 522         item = da_asg_malloc();
 523         item->text = g_strdup_printf( _("(assignment %d)"), da_asg_length()+1);
 524
 525         da_asg_append(item);
 526         ui_asg_listview_add(GTK_TREE_VIEW(data->LV_rul), item);
 527
 528         data->change++;
 529 }
 530
 531 /*
 532 ** delete the selected assign to our treeview and temp GList
 533 */
 534 static void ui_asg_manage_delete(GtkWidget *widget, gpointer user_data)
 535 {
 536 struct ui_asg_manage_data *data;
 537 guint32 key;
 538 gint result;
 539
 540         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 541         DB( g_print("\n(ui_asg_manage_remove) (data=%x)\n", (guint)data) );
 542
 543         key = ui_asg_listview_get_selected_key(GTK_TREE_VIEW(data->LV_rul));
 544         if( key > 0 )
 545         {
 546         Assign *item = da_asg_get(key);
 547         gchar *title = NULL;
 548         gchar *secondtext;
 549
 550                 title = g_strdup_printf (
 551                         _("Are you sure you want to permanently delete '%s'?"), item->text);
 552
 553                 secondtext = _("If you delete an assignment, it will be permanently lost.");
 554
 555                 result = ui_dialog_msg_confirm_alert(
 556                                 GTK_WINDOW(data->window),
 557                                 title,
 558                                 secondtext,
 559                                 _("_Delete")
 560                         );
 561
 562                 g_free(title);
 563
 564                 if( result == GTK_RESPONSE_OK )
 565                 {
 566                         da_asg_remove(key);
 567                         ui_asg_listview_remove_selected(GTK_TREE_VIEW(data->LV_rul));
 568                         data->change++;
 569                 }
 570         }
 571 }
 572
 573 /*
 574 ** rename the selected assign to our treeview and temp GList
 575 */
 576 static void ui_asg_manage_rename(GtkWidget *widget, gpointer user_data)
 577 {
 578 struct ui_asg_manage_data *data;
 579 guint32 key;
 580 gboolean error;
 581 gchar *txt;
 582
 583         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 584         DB( g_print("\n(ui_asg_manage_rename) (data=%x)\n", (guint)data) );
 585
 586         error = FALSE;
 587
 588         key = ui_asg_listview_get_selected_key(GTK_TREE_VIEW(data->LV_rul));
 589         if( key > 0 )
 590         {
 591         Assign *item = da_asg_get(key);
 592
 593                 txt = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_text));
 594                 if( txt == NULL || *txt == '\0' )
 595                 {
 596                         error = TRUE;
 597                         goto end;
 598                 }
 599
 600                 if( strcmp(txt, item->text) )
 601                 {
 602                         if( assign_rename(item, txt) == TRUE )
 603                         {
 604                                 //todo: review this count
 605                                 data->change++;
 606                                 gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_rul));
 607                         }
 608                         else
 609                                 error = TRUE;
 610                 }
 611         }
 612
 613 end:
 614         gtk_style_context_remove_class (gtk_widget_get_style_context (GTK_WIDGET(data->ST_text)), GTK_STYLE_CLASS_ERROR);
 615
 616         if( error == TRUE )
 617                 gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET(data->ST_text)), GTK_STYLE_CLASS_ERROR);
 618 }
 619
 620
 621 /*
 622 **
 623 */
 624 static void ui_asg_manage_selection(GtkTreeSelection *treeselection, gpointer user_data)
 625 {
 626         ui_asg_manage_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
 627 }
 628
 629 //gint ui_asg_manage_list_sort(struct _Assign *a, struct _Assign *b) { return( a->rul_Id - b->rul_Id); }
 630
 631 /*
 632 **
 633 */
 634 static gboolean ui_asg_manage_cleanup(struct ui_asg_manage_data *data, gint result)
 635 {
 636 guint32 key;
 637 gboolean doupdate = FALSE;
 638
 639         DB( g_print("\n(ui_asg_manage_cleanup) %x\n", (guint)data) );
 640
 641                 key = ui_asg_listview_get_selected_key(GTK_TREE_VIEW(data->LV_rul));
 642                 if(key > 0)
 643                 {
 644                         data->lastkey = key;
 645                         DB( g_print(" -> should first do a get for assign %d\n", data->lastkey) );
 646                         ui_asg_manage_getlast(data);
 647                 }
 648
 649                 // test for change & store new position
 650                 /*
 651                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(data->LV_rul));
 652                 i=1; valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
 653                 while (valid)
 654                 {
 655                 Assign *item;
 656
 657                         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
 658                                 LST_DEFASG_DATAS, &item,
 659                                 -1);
 660
 661                         DB( g_print(" -> check rul %d, pos is %d, %s\n", i, item->pos, item->text) );
 662
 663                         if(item->pos != i)
 664                                 data->change++;
 665
 666                         item->pos = i;
 667
 668                         // Make iter point to the next row in the list store
 669                         i++; valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter);
 670                 }
 671                 */
 672
 673         GLOBALS->changes_count += data->change;
 674
 675         return doupdate;
 676 }
 677
 678 /*
 679 **
 680 */
 681 static void ui_asg_manage_setup(struct ui_asg_manage_data *data)
 682 {
 683
 684         DB( g_print("\n(ui_asg_manage_setup)\n") );
 685
 686         //init GList
 687         data->tmp_list = NULL; //hb-glist_clone_list(GLOBALS->rul_list, sizeof(struct _Assign));
 688         data->action = 0;
 689         data->change = 0;
 690         data->lastkey = 0;
 691
 692         ui_asg_listview_populate(data->LV_rul);
 693
 694         ui_pay_comboboxentry_populate(GTK_COMBO_BOX(data->PO_pay), GLOBALS->h_pay);
 695         ui_cat_comboboxentry_populate(GTK_COMBO_BOX(data->PO_cat), GLOBALS->h_cat);
 696 }
 697
 698 static gchar *CYA_ASG_ACTION[] = {
 699         N_("Disabled"),
 700         N_("If empty"),
 701         N_("Overwrite"),
 702         NULL
 703 };
 704
 705
 706
 707 /*
 708 **
 709 */
 710 GtkWidget *ui_asg_manage_dialog (void)
 711 {
 712 struct ui_asg_manage_data data;
 713 GtkWidget *window, *content, *mainbox;
 714 GtkWidget *content_grid, *group_grid;
 715 GtkWidget *table, *label, *entry1;
 716 GtkWidget *scrollwin;
 717 GtkWidget *widget, *hpaned;
 718 gint w, h, crow, row;
 719
 720         window = gtk_dialog_new_with_buttons (_("Manage Assignments"),
 721                                 GTK_WINDOW(GLOBALS->mainwindow),
 722                                 0,
 723                             _("_Close"),
 724                             GTK_RESPONSE_ACCEPT,
 725                                 NULL);
 726
 727         data.window = window;
 728
 729         //set the window icon
 730         gtk_window_set_icon_name(GTK_WINDOW (window), ICONNAME_HB_ASSIGN);
 731
 732         //set a nice dialog size
 733         gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
 734         gtk_window_set_default_size (GTK_WINDOW(window), -1, h/PHI);
 735
 736         //store our window private data
 737         g_object_set_data(G_OBJECT(window), "inst_data", (gpointer)&data);
 738         DB( g_print("(ui_asg_manage_) window=%x, inst_data=%x\n", (guint)window, (guint)&data) );
 739
 740         //window contents
 741         content = gtk_dialog_get_content_area(GTK_DIALOG (window));             // return a vbox
 742
 743
 744         mainbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_SMALL);
 745         gtk_box_pack_start (GTK_BOX (content), mainbox, TRUE, TRUE, 0);
 746         gtk_container_set_border_width (GTK_CONTAINER(mainbox), SPACING_MEDIUM);
 747
 748         hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
 749         gtk_box_pack_start (GTK_BOX (mainbox), hpaned, TRUE, TRUE, 0);
 750
 751         /* left area */
 752         table = gtk_grid_new ();
 753         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_SMALL);
 754         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
 755         //gtk_box_pack_start (GTK_BOX (mainbox), table, FALSE, FALSE, 0);
 756         gtk_widget_set_margin_right(table, SPACING_SMALL);
 757         gtk_paned_pack1 (GTK_PANED(hpaned), table, FALSE, FALSE);
 758
 759         row = 0;
 760         scrollwin = gtk_scrolled_window_new(NULL,NULL);
 761         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 762         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
 763         data.LV_rul = ui_asg_listview_new(FALSE);
 764         gtk_widget_set_size_request(data.LV_rul, HB_MINWIDTH_LIST, -1);
 765         gtk_container_add(GTK_CONTAINER(scrollwin), data.LV_rul);
 766         gtk_widget_set_vexpand (scrollwin, TRUE);
 767         gtk_widget_set_hexpand (scrollwin, TRUE);
 768         gtk_grid_attach (GTK_GRID(table), scrollwin, 0, row, 2, 1);
 769
 770         row++;
 771         widget = gtk_button_new_with_mnemonic(_("_Add"));
 772         data.BT_add = widget;
 773         gtk_grid_attach (GTK_GRID(table), widget, 0, row, 1, 1);
 774
 775         widget = gtk_button_new_with_mnemonic(_("_Delete"));
 776         data.BT_rem = widget;
 777         gtk_grid_attach (GTK_GRID(table), widget, 1, row, 1, 1);
 778
 779
 780         /* right area */
 781         content_grid = gtk_grid_new();
 782         gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
 783         gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
 784         //gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
 785         gtk_widget_set_margin_left(content_grid, SPACING_SMALL);
 786         gtk_paned_pack2 (GTK_PANED(hpaned), content_grid, FALSE, FALSE);
 787
 788         // group :: Condition
 789         crow = 0;
 790     group_grid = gtk_grid_new ();
 791         data.GR_condition = group_grid;
 792         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 793         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 794         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow, 1, 1);
 795
 796         row = 0;
 797         label = make_label_group(_("Condition"));
 798         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 3, 1);
 799
 800         row++;
 801         label = make_label_widget(_("Search _in:"));
 802         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 803         widget = make_radio(CYA_ASG_FIELD, FALSE, GTK_ORIENTATION_HORIZONTAL);
 804         data.CY_field = widget;
 805         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 2, 1);
 806
 807         row++;
 808         //label = make_label_widget(_("Con_tains:"));
 809         label = make_label_widget(_("Fi_nd:"));
 810         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 811         entry1 = make_string(label);
 812         data.ST_text = entry1;
 813         gtk_widget_set_hexpand(entry1, TRUE);
 814         gtk_grid_attach (GTK_GRID (group_grid), entry1, 2, row, 2, 1);
 815
 816         row++;
 817         widget = gtk_check_button_new_with_mnemonic (_("Match _case"));
 818         data.CM_exact = widget;
 819         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 2, 1);
 820
 821         row++;
 822         widget = gtk_check_button_new_with_mnemonic (_("Use _regular expressions"));
 823         data.CM_re = widget;
 824         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 2, 1);
 825
 826         // Assignments
 827
 828         // group :: Assign payee
 829         crow++;
 830     group_grid = gtk_grid_new ();
 831         data.GR_pay = group_grid;
 832         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 833         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 834         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow, 1, 1);
 835
 836         row = 0;
 837         label = make_label_group(_("Assign payee"));
 838         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 3, 1);
 839
 840         row++;
 841         widget = make_radio(CYA_ASG_ACTION, FALSE, GTK_ORIENTATION_HORIZONTAL);
 842         data.RA_pay = widget;
 843         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 844
 845         row++;
 846         label = make_label_widget (_("_Payee:"));
 847         data.LB_pay = label;
 848         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 849
 850         widget = ui_pay_comboboxentry_new(label);
 851         data.PO_pay = widget;
 852         gtk_widget_set_hexpand(widget, TRUE);
 853         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 854
 855
 856         //gtk_widget_set_tooltip_text(widget, _("Autocompletion and direct seizure\nis available for Payee"));
 857
 858         crow++;
 859     group_grid = gtk_grid_new ();
 860         data.GR_cat = group_grid;
 861         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 862         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 863         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow, 1, 1);
 864
 865         row = 0;
 866         label = make_label_group(_("Assign category"));
 867         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 3, 1);
 868
 869         row++;
 870         widget = make_radio(CYA_ASG_ACTION, FALSE, GTK_ORIENTATION_HORIZONTAL);
 871         data.RA_cat = widget;
 872         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 873
 874         row++;
 875         label = make_label_widget (_("_Category:"));
 876         data.LB_cat = label;
 877         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 878
 879         widget = ui_cat_comboboxentry_new(label);
 880         data.PO_cat = widget;
 881         gtk_widget_set_hexpand(widget, TRUE);
 882         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 883
 884         //gtk_widget_set_tooltip_text(widget, _("Autocompletion and direct seizure\nis available for Category"));
 885
 886         crow++;
 887     group_grid = gtk_grid_new ();
 888         data.GR_mod = group_grid;
 889         gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 890         gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 891         gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow, 1, 1);
 892
 893         row = 0;
 894         label = make_label_group(_("Assign payment"));
 895         gtk_grid_attach (GTK_GRID (group_grid), label, 0, row, 3, 1);
 896
 897         row++;
 898         widget = make_radio(CYA_ASG_ACTION, FALSE, GTK_ORIENTATION_HORIZONTAL);
 899         data.RA_mod = widget;
 900         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 901
 902         row++;
 903         label = make_label_widget (_("Pay_ment:"));
 904         data.LB_mod = label;
 905         gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 906
 907         widget = make_paymode_nointxfer (label);
 908         data.NU_mod = widget;
 909         gtk_widget_set_hexpand(widget, TRUE);
 910         gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 911
 912         //ugly hack
 913         //gtk_widget_set_tooltip_text(widget, _("Internal transfer unsupported\nin auto assignments"));
 914
 915
 916         //connect all our signals
 917         g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
 918
 919         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data.LV_rul)), "changed", G_CALLBACK (ui_asg_manage_selection), NULL);
 920
 921         g_signal_connect (G_OBJECT (data.ST_text), "changed", G_CALLBACK (ui_asg_manage_rename), NULL);
 922
 923         widget = radio_get_nth_widget(GTK_CONTAINER(data.RA_pay), 0);
 924         if(widget)
 925                 g_signal_connect (widget, "toggled", G_CALLBACK (ui_asg_manage_update_assignments), NULL);
 926
 927         widget = radio_get_nth_widget(GTK_CONTAINER(data.RA_cat), 0);
 928         if(widget)
 929                 g_signal_connect (widget, "toggled", G_CALLBACK (ui_asg_manage_update_assignments), NULL);
 930
 931         widget = radio_get_nth_widget(GTK_CONTAINER(data.RA_mod), 0);
 932         if(widget)
 933                 g_signal_connect (widget, "toggled", G_CALLBACK (ui_asg_manage_update_assignments), NULL);
 934
 935         g_signal_connect (G_OBJECT (data.BT_add), "clicked", G_CALLBACK (ui_asg_manage_add), NULL);
 936         g_signal_connect (G_OBJECT (data.BT_rem), "clicked", G_CALLBACK (ui_asg_manage_delete), NULL);
 937
 938         //setup, init and show window
 939         ui_asg_manage_setup(&data);
 940         ui_asg_manage_update(data.LV_rul, NULL);
 941
 942 //      gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
 943
 944         gtk_widget_show_all (window);
 945
 946         //wait for the user
 947         gint result = gtk_dialog_run (GTK_DIALOG (window));
 948
 949         // cleanup and destroy
 950         ui_asg_manage_cleanup(&data, result);
 951         gtk_widget_destroy (window);
 952
 953         return NULL;
 954 }
 955
 956