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

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