Dogcows Code - chaz/homebank/blob - src/ui-widgets.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 "gtk-chart.h"
  24 #include "ui-widgets.h"
  25
  26 /****************************************************************************/
  27 /* Debug macros                                                             */
  28 /****************************************************************************/
  29 #define MYDEBUG 0
  30
  31 #if MYDEBUG
  32 #define DB(x) (x);
  33 #else
  34 #define DB(x);
  35 #endif
  36
  37 /* our global datas */
  38 extern struct HomeBank *GLOBALS;
  39
  40
  41 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  42
  43
  44 extern gchar *CYA_FLT_RANGE[];
  45
  46
  47
  48
  49 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  50
  51
  52
  53 void
  54 gimp_label_set_attributes (GtkLabel *label,
  55                            ...)
  56 {
  57   PangoAttribute *attr  = NULL;
  58   PangoAttrList  *attrs;
  59   va_list         args;
  60
  61   g_return_if_fail (GTK_IS_LABEL (label));
  62
  63   attrs = pango_attr_list_new ();
  64
  65   va_start (args, label);
  66
  67   do
  68     {
  69       PangoAttrType attr_type = va_arg (args, PangoAttrType);
  70
  71       if (attr_type <= 0)
  72         attr_type = PANGO_ATTR_INVALID;
  73
  74       switch (attr_type)
  75         {
  76         case PANGO_ATTR_LANGUAGE:
  77           attr = pango_attr_language_new (va_arg (args, PangoLanguage *));
  78           break;
  79
  80         case PANGO_ATTR_FAMILY:
  81           attr = pango_attr_family_new (va_arg (args, const gchar *));
  82           break;
  83
  84         case PANGO_ATTR_STYLE:
  85           attr = pango_attr_style_new (va_arg (args, PangoStyle));
  86           break;
  87
  88         case PANGO_ATTR_WEIGHT:
  89           attr = pango_attr_weight_new (va_arg (args, PangoWeight));
  90           break;
  91
  92         case PANGO_ATTR_VARIANT:
  93           attr = pango_attr_variant_new (va_arg (args, PangoVariant));
  94           break;
  95
  96         case PANGO_ATTR_STRETCH:
  97           attr = pango_attr_stretch_new (va_arg (args, PangoStretch));
  98           break;
  99
 100         case PANGO_ATTR_SIZE:
 101           attr = pango_attr_size_new (va_arg (args, gint));
 102           break;
 103
 104         case PANGO_ATTR_FONT_DESC:
 105           attr = pango_attr_font_desc_new (va_arg (args,
 106                                                    const PangoFontDescription *));
 107           break;
 108
 109         case PANGO_ATTR_FOREGROUND:
 110           {
 111             const PangoColor *color = va_arg (args, const PangoColor *);
 112
 113             attr = pango_attr_foreground_new (color->red,
 114                                               color->green,
 115                                               color->blue);
 116           }
 117           break;
 118
 119         case PANGO_ATTR_BACKGROUND:
 120           {
 121             const PangoColor *color = va_arg (args, const PangoColor *);
 122
 123             attr = pango_attr_background_new (color->red,
 124                                               color->green,
 125                                               color->blue);
 126           }
 127           break;
 128
 129         case PANGO_ATTR_UNDERLINE:
 130           attr = pango_attr_underline_new (va_arg (args, PangoUnderline));
 131           break;
 132
 133         case PANGO_ATTR_STRIKETHROUGH:
 134           attr = pango_attr_strikethrough_new (va_arg (args, gboolean));
 135           break;
 136
 137         case PANGO_ATTR_RISE:
 138           attr = pango_attr_rise_new (va_arg (args, gint));
 139           break;
 140
 141         case PANGO_ATTR_SCALE:
 142           attr = pango_attr_scale_new (va_arg (args, gdouble));
 143           break;
 144
 145         default:
 146           //g_warning ("%s: invalid PangoAttribute type %d", G_STRFUNC, attr_type);
 147         case PANGO_ATTR_INVALID:
 148           attr = NULL;
 149           break;
 150         }
 151
 152       if (attr)
 153         {
 154           attr->start_index = 0;
 155           attr->end_index   = -1;
 156           pango_attr_list_insert (attrs, attr);
 157         }
 158     }
 159   while (attr);
 160
 161   va_end (args);
 162
 163   gtk_label_set_attributes (label, attrs);
 164   pango_attr_list_unref (attrs);
 165 }
 166
 167
 168 void hb_widget_visible(GtkWidget *widget, gboolean visible)
 169 {
 170         if(!GTK_IS_WIDGET(widget))
 171                 return;
 172
 173         if(visible)
 174         {
 175                 gtk_widget_show(widget);
 176         }
 177         else
 178         {
 179                 gtk_widget_hide(widget);
 180         }
 181 }
 182
 183
 184 void ui_label_set_integer(GtkLabel *label, gint value)
 185 {
 186 gchar buf[16];
 187
 188         g_snprintf(buf, 16, "%d", value);
 189         gtk_label_set_text (label, buf);
 190 }
 191
 192
 193 void ui_gtk_entry_set_text(GtkWidget *widget, gchar *text)
 194 {
 195         DB( g_print(" set text to '%s'\n", text) );
 196
 197         if( text != NULL )
 198                 gtk_entry_set_text(GTK_ENTRY(widget), text);
 199         else
 200                 gtk_entry_set_text(GTK_ENTRY(widget), "");
 201 }
 202
 203 void ui_gtk_entry_replace_text(GtkWidget *widget, gchar **storage)
 204 {
 205 const gchar *text;
 206
 207         DB( g_print(" storage is '%p' at '%p'\n", *storage, storage) );
 208
 209         /* free any previous string */
 210         if( *storage != NULL )
 211         {
 212                 g_free(*storage);
 213         }
 214
 215         *storage = NULL;
 216         text = gtk_entry_get_text(GTK_ENTRY(widget));
 217         *storage = g_strdup(text);
 218 }
 219
 220
 221 GtkWidget *make_label_group(gchar *str)
 222 {
 223 GtkWidget *label = gtk_label_new (str);
 224
 225         gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
 226         gtk_widget_set_halign (label, GTK_ALIGN_START);
 227         gimp_label_set_attributes(GTK_LABEL(label), PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1);
 228         return label;
 229 }
 230
 231
 232 GtkWidget *make_label_widget(char *str)
 233 {
 234 GtkWidget *label = gtk_label_new_with_mnemonic (str);
 235
 236         gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
 237         gtk_widget_set_halign (label, GTK_ALIGN_END);
 238         return label;
 239 }
 240
 241
 242 GtkWidget *make_label(char *str, gfloat xalign, gfloat yalign)
 243 {
 244 GtkWidget *label = gtk_label_new_with_mnemonic (str);
 245
 246         //todo: deprecated in 3.14
 247         gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
 248         //gtk_label_set_xalign(GTK_LABEL(label), xalign);
 249         //gtk_label_set_yalign(GTK_LABEL(label), yalign);
 250         return label;
 251 }
 252
 253
 254 /*
 255 **
 256 */
 257 GtkWidget *make_text(gfloat xalign)
 258 {
 259 GtkWidget *entry;
 260
 261         entry = gtk_entry_new ();
 262         gtk_editable_set_editable (GTK_EDITABLE(entry), FALSE);
 263         g_object_set(entry, "xalign", xalign, NULL);
 264         return entry;
 265 }
 266
 267
 268 GtkWidget *make_search(GtkWidget *label)
 269 {
 270 GtkWidget *search;
 271
 272         search = gtk_search_entry_new();
 273         gtk_entry_set_placeholder_text(GTK_ENTRY(search), _("Search...") );
 274
 275         if(label)
 276                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), search);
 277
 278         return search;
 279 }
 280
 281
 282
 283 /*
 284 **
 285 */
 286 GtkWidget *make_string(GtkWidget *label)
 287 {
 288 GtkWidget *entry;
 289
 290         entry = gtk_entry_new ();
 291
 292         if(label)
 293                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), entry);
 294
 295         return entry;
 296 }
 297
 298
 299 GtkWidget *make_image_button(gchar *icon_name, gchar *tooltip_text)
 300 {
 301 GtkWidget *button, *image;
 302
 303         //todo 3.10 use gtk_button_new_from_icon_name
 304
 305         button = gtk_button_new();
 306         image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
 307         g_object_set (button, "image", image, NULL);
 308         if(tooltip_text != NULL)
 309                 gtk_widget_set_tooltip_text(button, tooltip_text);
 310
 311         return button;
 312 }
 313
 314
 315
 316 /*
 317 **
 318 */
 319 GtkWidget *make_memo_entry(GtkWidget *label)
 320 {
 321 GtkListStore *store;
 322 GtkWidget *entry;
 323 GtkEntryCompletion *completion;
 324 GList *lmem, *list;
 325
 326         store = gtk_list_store_new (1, G_TYPE_STRING);
 327
 328     completion = gtk_entry_completion_new ();
 329     gtk_entry_completion_set_model (completion, GTK_TREE_MODEL(store));
 330     gtk_entry_completion_set_text_column (completion, 0);
 331
 332         entry = gtk_entry_new ();
 333         gtk_entry_set_completion (GTK_ENTRY (entry), completion);
 334
 335         g_object_unref(store);
 336
 337         //populate
 338         //gtk_list_store_clear (GTK_LIST_STORE(store));
 339
 340         lmem = list = g_hash_table_get_keys(GLOBALS->h_memo);
 341         while (list != NULL)
 342         {
 343         GtkTreeIter  iter;
 344
 345                 gtk_list_store_append (GTK_LIST_STORE(store), &iter);
 346                 gtk_list_store_set (GTK_LIST_STORE(store), &iter, 0, list->data, -1);
 347
 348                 list = g_list_next(list);
 349         }
 350
 351         g_list_free(lmem);
 352
 353         if(label)
 354                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), entry);
 355
 356         return entry;
 357 }
 358
 359
 360 /*
 361 **
 362 */
 363 GtkWidget *make_string_maxlength(GtkWidget *label, guint max_length)
 364 {
 365 GtkWidget *entry;
 366
 367         entry = make_string(label);
 368         gtk_entry_set_max_length(GTK_ENTRY(entry), max_length);
 369
 370         return entry;
 371 }
 372
 373
 374
 375 static void hb_amount_insert_text_handler (GtkEntry *entry, const gchar *text, gint length, gint *position, gpointer data)
 376 {
 377 GtkEditable *editable = GTK_EDITABLE(entry);
 378 int i, count=0, dcpos=-1;
 379 gchar *result = g_new0 (gchar, length+1);
 380 const gchar *numtext;
 381
 382         //g_message("insert_text-handler: text:%s - pos:%d - length:%d", text, *position, length);
 383
 384         numtext = gtk_entry_get_text(entry);
 385         for (i=0 ; numtext[i]!='\0' ; i++)
 386         {
 387                 if(numtext[i]==',' || numtext[i]=='.')
 388                         dcpos = i;
 389         }
 390
 391
 392         //g_message("previous text='%s' dcpos:'%d'", numtext, dcpos);
 393         for (i=0 ; i < length ; i++)
 394         {
 395                 if( isdigit(text[i]) && ( (*position <= dcpos+2) || dcpos < 0) )
 396                         goto inserttext;
 397
 398                 if( text[i]=='-' && *position==0 )      /* minus sign only at position 0 */
 399                         goto inserttext;
 400
 401                 if( dcpos < 0 && (text[i]=='.' || text[i]==',') )       /* decimal separator if not in previous string */
 402                         result[count++] = '.';
 403
 404                 continue;
 405
 406         inserttext:
 407                 result[count++] = text[i];
 408         }
 409
 410         if (count > 0) {
 411                 g_signal_handlers_block_by_func (G_OBJECT (editable), G_CALLBACK (hb_amount_insert_text_handler), data);
 412                 gtk_editable_insert_text (editable, result, count, position);
 413                 g_signal_handlers_unblock_by_func (G_OBJECT (editable), G_CALLBACK (hb_amount_insert_text_handler), data);
 414         }
 415         g_signal_stop_emission_by_name (G_OBJECT (editable), "insert-text");
 416
 417         g_free (result);
 418 }
 419
 420 /*
 421 **
 422 */
 423 GtkWidget *make_amount(GtkWidget *label)
 424 {
 425 GtkWidget *spinner;
 426 GtkAdjustment *adj;
 427
 428         //adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -G_MAXDOUBLE, G_MAXDOUBLE, 0.01, 1.0, 0.0);
 429         adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -8589934588, 8589934588, 0.01, 1.0, 0.0);
 430         spinner = gtk_spin_button_new (adj, 1.0, 2);
 431         g_object_set(spinner, "xalign", 1.0, NULL);
 432
 433         if(label)
 434                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), spinner);
 435
 436         g_signal_connect(G_OBJECT(spinner), "insert-text",
 437                          G_CALLBACK(hb_amount_insert_text_handler),
 438                          NULL);
 439
 440         return spinner;
 441 }
 442
 443
 444 GtkWidget *make_exchange_rate(GtkWidget *label)
 445 {
 446 GtkWidget *spinner;
 447 GtkAdjustment *adj;
 448
 449         adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, 99999, 0.01, 1.0, 0.0);
 450         spinner = gtk_spin_button_new (adj, 1.0, 6);
 451         //gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
 452         gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
 453         g_object_set(spinner, "xalign", 1.0, NULL);
 454
 455         if(label)
 456                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), spinner);
 457
 458         return spinner;
 459 }
 460
 461 /*
 462 **
 463 */
 464 GtkWidget *make_numeric(GtkWidget *label, gdouble min, gdouble max)
 465 {
 466 GtkWidget *spinner;
 467 GtkAdjustment *adj;
 468
 469         adj = (GtkAdjustment *) gtk_adjustment_new (0.0, min, max, 1.0, 10.0, 0.0);
 470         spinner = gtk_spin_button_new (adj, 0, 0);
 471         //gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
 472         gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
 473         g_object_set(spinner, "xalign", 1.0, NULL);
 474
 475         if(label)
 476                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), spinner);
 477
 478         return spinner;
 479 }
 480
 481 /*
 482 **
 483 */
 484 GtkWidget *make_scale(GtkWidget *label)
 485 {
 486 GtkWidget *scale;
 487
 488         scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, GTK_CHART_MINBARW, GTK_CHART_MAXBARW, 1.0);
 489         gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
 490         gtk_range_set_value(GTK_RANGE(scale), GTK_CHART_BARW);
 491
 492         if(label)
 493                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), scale);
 494
 495         return scale;
 496 }
 497
 498 /*
 499 **
 500 */
 501 GtkWidget *make_long(GtkWidget *label)
 502 {
 503 GtkWidget *spinner;
 504
 505         spinner = make_numeric(label, 0.0, G_MAXINT);
 506         return spinner;
 507 }
 508
 509
 510 GtkWidget *make_year(GtkWidget *label)
 511 {
 512 GtkWidget *spinner;
 513 GtkAdjustment *adj;
 514
 515         adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 1900, 2200, 1.0, 10.0, 0.0);
 516         spinner = gtk_spin_button_new (adj, 0, 0);
 517         gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
 518         gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
 519         g_object_set(spinner, "xalign", 1.0, NULL);
 520
 521         if(label)
 522                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), spinner);
 523
 524         return spinner;
 525 }
 526
 527
 528 static gboolean
 529 is_separator (GtkTreeModel *model,
 530               GtkTreeIter  *iter,
 531               gpointer      data)
 532 {
 533   //GtkTreePath *path;
 534   gboolean retval;
 535   gchar *txt;
 536
 537         gtk_tree_model_get (model, iter, 0, &txt, -1);
 538
 539         retval = *txt == 0 ? TRUE : FALSE;
 540   //path = gtk_tree_model_get_path (model, iter);
 541   //result = gtk_tree_path_get_indices (path)[0] == 4;
 542   //gtk_tree_path_free (path);
 543
 544   return retval;
 545 }
 546
 547 static void
 548 set_sensitive (GtkCellLayout   *cell_layout,
 549                GtkCellRenderer *cell,
 550                GtkTreeModel    *tree_model,
 551                GtkTreeIter     *iter,
 552                gpointer         data)
 553 {
 554   GtkTreePath *path;
 555   gint *indices;
 556   gboolean sensitive;
 557
 558   path = gtk_tree_model_get_path (tree_model, iter);
 559   indices = gtk_tree_path_get_indices (path);
 560   sensitive = indices[0] != FLT_RANGE_OTHER;
 561   gtk_tree_path_free (path);
 562
 563   g_object_set (cell, "sensitive", sensitive, NULL);
 564 }
 565
 566
 567 GtkWidget *make_cycle(GtkWidget *label, gchar **items)
 568 {
 569 GtkWidget *combobox;
 570 guint i;
 571
 572         combobox = gtk_combo_box_text_new ();
 573
 574         for (i = 0; items[i] != NULL; i++)
 575         {
 576                 if(*items[i] != 0)
 577                         gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(combobox), _(items[i]));
 578                 else
 579                         gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(combobox), "");
 580         }
 581         gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
 582         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox), is_separator, NULL, NULL);
 583
 584         if(label)
 585                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), combobox);
 586
 587         return combobox;
 588 }
 589
 590
 591 GtkWidget *make_daterange(GtkWidget *label, gboolean custom)
 592 {
 593 GtkWidget *combobox;
 594 GList *renderers, *list;
 595 GtkCellRenderer *renderer;
 596 gchar **items = CYA_FLT_RANGE;
 597 guint i;
 598
 599         combobox = gtk_combo_box_text_new ();
 600
 601         for (i = 0; items[i] != NULL; i++)
 602         {
 603                 if(*items[i] != 0)
 604                         gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(combobox), _(items[i]));
 605                 else
 606                         gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(combobox), "");
 607         }
 608         gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
 609
 610         if(label)
 611                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), combobox);
 612
 613         // special stuffs
 614         renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT(combobox));
 615         if(g_list_length(renderers) == 1 && custom == FALSE)
 616         {
 617                 list = g_list_first(renderers);
 618                 renderer = list->data;
 619
 620
 621                 gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
 622                                                 renderer,
 623                                                 set_sensitive,
 624                                                 NULL, NULL);
 625         }
 626         g_list_free(renderers);
 627
 628         gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox), is_separator, NULL, NULL);
 629
 630         return combobox;
 631 }
 632
 633 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 634
 635 /*
 636 **
 637 */
 638 GtkWidget *make_radio(gchar **items, gboolean buttonstyle, GtkOrientation orientation)
 639 {
 640 GtkWidget *box, *button;
 641 guint i;
 642
 643         box = gtk_box_new (orientation, 0);
 644
 645     button = gtk_radio_button_new_with_label (NULL, _(items[0]));
 646         gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), !buttonstyle);
 647     gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
 648         for (i = 1; items[i] != NULL; i++)
 649         {
 650                 button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (button), _(items[i]));
 651                 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), !buttonstyle);
 652             gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
 653         }
 654
 655         if(buttonstyle)
 656         {
 657                 gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
 658                 gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
 659         }
 660
 661         return box;
 662 }
 663
 664
 665 gint radio_get_active (GtkContainer *container)
 666 {
 667 GList *lchild, *list;
 668 GtkWidget *radio;
 669 gint i, retval = 0;
 670
 671         if(!GTK_IS_CONTAINER(container))
 672                 return -1;
 673
 674         lchild = list = gtk_container_get_children (container);
 675         for(i=0;list != NULL;i++)
 676         {
 677                 radio = list->data;
 678                 if(GTK_IS_TOGGLE_BUTTON(radio))
 679                 {
 680                         if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio)) == TRUE )
 681                         {
 682                                 retval = i;
 683                                 break;
 684                         }
 685                 }
 686                 list = g_list_next(list);
 687         }
 688         g_list_free(lchild);
 689
 690         return retval;
 691 }
 692
 693 GtkWidget *radio_get_nth_widget (GtkContainer *container, gint nth)
 694 {
 695 GList *lchild, *list;
 696 GtkWidget *radio;
 697
 698         if(!GTK_IS_CONTAINER(container))
 699                 return NULL;
 700
 701         lchild = list = gtk_container_get_children (container);
 702         radio = g_list_nth_data (list, nth);
 703         g_list_free(lchild);
 704         return radio;   //may return NULL
 705 }
 706
 707
 708
 709 void radio_set_active (GtkContainer *container, gint active)
 710 {
 711 GList *lchild, *list;
 712 GtkWidget *radio;
 713
 714         if(!GTK_IS_CONTAINER(container))
 715                 return;
 716
 717         lchild = list = gtk_container_get_children (container);
 718         radio = g_list_nth_data (list, active);
 719         if(radio != NULL && GTK_IS_TOGGLE_BUTTON(radio))
 720         {
 721                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radio), TRUE);
 722         }
 723         g_list_free(lchild);
 724 }
 725
 726
 727 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 728
 729 /*
 730 id  ofx                         english                           french
 731  ---------------------------------------------------------------------
 732  0      --------        (none)                            (aucun)
 733  1      --------        credit card                       carte de crédit
 734  2      OFX_CHECK       Check                             cheque
 735  3  OFX_CASH            Cash    withdrawal                retrait espece
 736  4      OFX_XFER        Transfer                          virement
 737  5      --------        internal transfer                 virement compte
 738  6      --------        (debit card)                      (carte de paiement
 739  7      OFX_REPEATPMT   Repeating payment/standing order  Paiement recurrent/Virement auto.
 740
 741  8      OFX_PAYMENT     Electronic payment                télépaiement
 742  9      OFX_DEP             Deposit                           dépôt
 743 10      OFX_FEE         FI fee                            frais bancaires
 744
 745
 746          OFX_DIRECTDEBIT        Merchant initiated debit     prelevement
 747          OFX_OTHER      Somer other type of transaction      autre
 748
 749 other OFX values:
 750
 751 OFX_CREDIT      Generic credit
 752 OFX_DEBIT       Generic debit
 753 OFX_INT         Interest earned or paid (Note: Depends on signage of amount)
 754 OFX_DIV         Dividend
 755 OFX_SRVCHG      Service charge
 756 -OFX_DEP        Deposit
 757 OFX_ATM         ATM debit or credit (Note: Depends on signage of amount)
 758 OFX_POS         Point of sale debit or credit (Note: Depends on signage of amount)
 759 -OFX_XFER       Transfer
 760 -OFX_CHECK      Check
 761 -OFX_PAYMENT    Electronic payment
 762 -OFX_CASH       Cash withdrawal
 763 OFX_DIRECTDEP   Direct deposit
 764 OFX_DIRECTDEBIT         Merchant initiated debit
 765 -OFX_REPEATPMT  Repeating payment/standing order
 766 OFX_OTHER       Somer other type of transaction
 767 */
 768
 769 enum
 770 {
 771         LST_PAYMODE_ICONNAME,
 772         LST_PAYMODE_LABEL,
 773         NUM_LST_PAYMODE
 774 };
 775
 776 char *paymode_iconnames[NUM_PAYMODE_MAX] =
 777 {
 778         "pm-none",
 779         "pm-ccard",
 780         "pm-check",
 781         "pm-cash" ,
 782         "pm-transfer",
 783         "pm-intransfer",
 784         "pm-dcard",
 785         "pm-standingorder",
 786         "pm-epayment",
 787         "pm-deposit",
 788         "pm-fifee",
 789         "pm-directdebit"
 790 };
 791
 792 char *paymode_label_names[NUM_PAYMODE_MAX] =
 793 {
 794         N_("(none)"),
 795         N_("Credit card"),
 796         N_("Check"),
 797         N_("Cash"),
 798         N_("Transfer"),
 799         N_("Internal transfer"),
 800         N_("Debit card"),
 801         N_("Standing order"),
 802         N_("Electronic payment"),
 803         N_("Deposit"),
 804         //TRANSLATORS: Financial institution fee
 805         N_("FI fee"),
 806         N_("Direct Debit")
 807 };
 808
 809 /* nota: used in ui-filter */
 810 gchar *get_paymode_icon_name(gint index)
 811 {
 812         if(index >= NUM_PAYMODE_MAX)
 813                 return NULL;
 814
 815         return paymode_iconnames[index];
 816 }
 817
 818
 819 /*
 820 ** Make a paymode combobox widget
 821 */
 822
 823 static void
 824 paymode_set_sensitive (GtkCellLayout   *cell_layout,
 825                GtkCellRenderer *cell,
 826                GtkTreeModel    *tree_model,
 827                GtkTreeIter     *iter,
 828                gpointer         data)
 829 {
 830   GtkTreePath *path;
 831   gint *indices;
 832   gboolean sensitive;
 833
 834   path = gtk_tree_model_get_path (tree_model, iter);
 835   indices = gtk_tree_path_get_indices (path);
 836   sensitive = (indices[0] == PAYMODE_INTXFER) ? FALSE : TRUE;
 837   gtk_tree_path_free (path);
 838
 839
 840   g_object_set (cell, "sensitive", sensitive, NULL);
 841 }
 842
 843
 844
 845 static GtkWidget *make_paymode_internal(GtkWidget *label, gboolean intxfer)
 846 {
 847 GtkListStore *store;
 848 GtkTreeIter iter;
 849 GtkWidget *combobox;
 850 GtkCellRenderer *renderer, *r1, *r2;
 851 guint i;
 852
 853         store = gtk_list_store_new (
 854                 NUM_LST_PAYMODE,
 855                 G_TYPE_STRING,
 856                 G_TYPE_STRING
 857                 );
 858
 859         combobox = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
 860
 861         renderer = r1 = gtk_cell_renderer_pixbuf_new();
 862         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox), renderer, FALSE);
 863         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(combobox), renderer, "icon-name", LST_PAYMODE_ICONNAME);
 864
 865         renderer = r2 = gtk_cell_renderer_text_new();
 866         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox), renderer, FALSE);
 867         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(combobox), renderer, "text", LST_PAYMODE_LABEL);
 868
 869
 870         if( intxfer == FALSE )
 871         {
 872                 gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
 873                                                 r1,
 874                                                 paymode_set_sensitive,
 875                                                 NULL, NULL);
 876                 gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
 877                                                 r2,
 878                                                 paymode_set_sensitive,
 879                                                 NULL, NULL);
 880         }
 881
 882         //populate our combobox model
 883         for(i=0;i<NUM_PAYMODE_MAX;i++)
 884         {
 885                 gtk_list_store_append(store, &iter);
 886                 gtk_list_store_set(store, &iter,
 887                         LST_PAYMODE_ICONNAME, paymode_iconnames[i],
 888                         LST_PAYMODE_LABEL, _(paymode_label_names[i]),
 889                         -1);
 890         }
 891
 892         gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
 893
 894         if(label)
 895                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), combobox);
 896
 897         return combobox;
 898 }
 899
 900
 901
 902
 903 GtkWidget *make_paymode(GtkWidget *label)
 904 {
 905         return make_paymode_internal(label, TRUE);
 906 }
 907
 908 GtkWidget *make_paymode_nointxfer(GtkWidget *label)
 909 {
 910         return make_paymode_internal(label, FALSE);
 911 }
 912
 913
 914 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 915
 916 #define NUM_NAINEX_MAX 3
 917
 918 enum
 919 {
 920         LST_NAINEX_ICONNAME,
 921         LST_NAINEX_LABEL,
 922         NUM_LST_NAINEX
 923 };
 924
 925 char *nainex_iconnames[NUM_NAINEX_MAX] =
 926 {
 927         "flt-inactive",
 928         "flt-include",
 929         "flt-exclude",
 930 };
 931
 932 char *nainex_label_names[NUM_NAINEX_MAX] =
 933 {
 934         N_("Inactive"),
 935         N_("Include"),
 936         N_("Exclude")
 937 };
 938
 939
 940 /*
 941 ** Make a nainex combobox widget
 942 */
 943 GtkWidget *make_nainex(GtkWidget *label)
 944 {
 945 GtkListStore  *store;
 946 GtkTreeIter    iter;
 947 GtkWidget *combobox;
 948 GtkCellRenderer    *renderer;
 949 guint i;
 950
 951         //store
 952         store = gtk_list_store_new (
 953                 NUM_LST_NAINEX,
 954                 G_TYPE_STRING,
 955                 G_TYPE_STRING
 956                 );
 957
 958         //combobox
 959         combobox = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
 960
 961         //column 1
 962         renderer = gtk_cell_renderer_pixbuf_new();
 963         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox), renderer, FALSE);
 964         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(combobox), renderer, "icon-name", LST_NAINEX_ICONNAME);
 965
 966         renderer = gtk_cell_renderer_text_new();
 967         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox), renderer, FALSE);
 968         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(combobox), renderer, "text", LST_NAINEX_LABEL);
 969
 970         gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
 971
 972         //populate our combobox model
 973         for(i=0;i<NUM_NAINEX_MAX;i++)
 974         {
 975                 gtk_list_store_append(store, &iter);
 976                 gtk_list_store_set(store, &iter,
 977                         LST_NAINEX_ICONNAME, nainex_iconnames[i],
 978                         LST_NAINEX_LABEL, _(nainex_label_names[i]),
 979                         -1);
 980         }
 981         gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
 982
 983         if(label)
 984                 gtk_label_set_mnemonic_widget (GTK_LABEL(label), combobox);
 985
 986         return combobox;
 987 }
 988