emufs_gui/gui.c

   1
   2
   3 #include <stdlib.h>
   4 #include <curses.h>
   5 #include <menu.h>
   6 #include <signal.h>
   7 #include <string.h>
   8 #include <stdarg.h>
   9
  10 #include "menu.h"
  11 #include "form.h"
  12 #include "articulos.h"
  13 #include "facturas.h"
  14 #include "emufs.h"
  15 #include "registros.h"
  16
  17 #define CTRLD 4
  18
  19 static void finish(int sig);
  20
  21 int main_menu();
  22 void menu_articulos();
  23 void menu_facturas();
  24 void menu_mantenimiento();
  25 void menu_estadisticas();
  26 void preguntar_nuevo_tipo(int *tipo, int *tam_bloque, int *tam_reg);
  27
  28 void ver_estadisticas(EMUFS *fp);
  29
  30 /* cuadro de msg. w y h son de la ventana padre */
  31 WINDOW *msg_box(WINDOW *win, int w, int h, const char *format, ...);
  32 void msg_box_free(WINDOW *padre, WINDOW *win);
  33
  34 typedef enum {
  35                 PARAM_OK, /* Parametros estan ok */
  36                 NO_ART_FILE,  /* No se especifico nombre de archivo Articulos */
  37                 NO_FACT_FILE, /* No se especifico nombre de archivo Facturas */
  38                 SHOW_HELP,    /* Mostrar ayuda encontrado */
  39                 TIPO_NO_DEFINIDO, /* No se definio tipo de archivo */
  40                 TIPO_INVALIDO,    /* El valor de tipo de archivo no es valido */
  41                 BLOQUE_NO_DEFINIDO, /* No se especifico tamaño de bloque */
  42                 NULL_BLOCK_FOUND    /* Tamaño de bloque <= 0!!! */
  43 } t_Param;
  44
  45 struct _mis_param_ {
  46         int xml_fact; /* Pos en argv  del archivo XML a usar para facturas */
  47         int xml_art; /* Pos en argv del archivo XML a usar para articulos */
  48         char tipo_arch_fact; /* Tipo de archivo para Facturas */
  49         char tipo_arch_art; /* Tipo de archivo para Articulos */
  50         EMUFS_BLOCK_SIZE tam_bloque_fact;
  51         EMUFS_BLOCK_SIZE tam_bloque_art;
  52 } parametros;
  53
  54 /* Verifica Argumentos */
  55 t_Param param_ok(int argc, char *argv[])
  56 {
  57         int n,i;
  58         for(i=1; i<argc; i++) {
  59                 if ((strcmp(argv[i], "-h")==0) || (strcmp(argv[i], "--help")==0)) return SHOW_HELP;
  60
  61                 if (strcmp(argv[i], "-a") == 0) { /* Articulos! */
  62                         i++;
  63                         if (i >= argc) return SHOW_HELP;
  64                         if (strcmp(argv[i]+strlen(argv[i])-3, "xml") == 0) {
  65                                 /* Luego del archivo XML debe seguir el tipo */
  66                                 if ((i+1)<argc) {
  67                                         n = atoi(argv[i+1]);
  68                                         if ((n < 1) || (n > 3)) return TIPO_INVALIDO;
  69                                         if (((n == 1) || (n == 3)) && ((i+2)>=argc))
  70                                                 return BLOQUE_NO_DEFINIDO;
  71                                         parametros.tipo_arch_art = n;
  72                                         parametros.tam_bloque_art = atoi(argv[i+2]);
  73                                         fprintf(stderr, "%d\n", parametros.tam_bloque_art);
  74                                         if (parametros.tam_bloque_art <= 0) return NULL_BLOCK_FOUND;
  75                                         parametros.xml_art = i;
  76                                 } else {
  77                                         /* Ops, no hay mas parametros */
  78                                         return TIPO_NO_DEFINIDO;
  79                                 }
  80                         } else {
  81                                 return NO_ART_FILE;
  82                         }
  83                 } /* Articulos */
  84
  85                 if (strcmp(argv[i], "-f") == 0) { /* Facturas! */
  86                         i++;
  87                         if (i >= argc) return SHOW_HELP;
  88                         if (strcmp(argv[i]+strlen(argv[i])-3, "xml") == 0) {
  89                                 /* Luego del archivo XML debe seguir el tipo */
  90                                 if ((i+1)<argc) {
  91                                         n = atoi(argv[i+1]);
  92                                         if ((n < 1) || (n > 3)) return TIPO_INVALIDO;
  93                                         if (((n == 1) || (n == 3)) && ((i+2)>=argc))
  94                                                 return BLOQUE_NO_DEFINIDO;
  95                                         parametros.tipo_arch_fact = n;
  96                                         parametros.tam_bloque_fact = atoi(argv[i+2]);
  97                                         if (parametros.tam_bloque_fact <= 0) return NULL_BLOCK_FOUND;
  98                                         parametros.xml_fact = i;
  99                                 } else {
 100                                         /* Ops, no hay mas parametros */
 101                                         return TIPO_NO_DEFINIDO;
 102                                 }
 103                         } else {
 104                                 return NO_FACT_FILE;
 105                         }
 106                 } /* Facturas */
 107
 108         }
 109         return PARAM_OK;
 110 }
 111
 112 void print_help(char *s)
 113 {
 114         printf("EMUFS - 1v0\n");
 115         printf("Modo de uso : %s [-[f|a] <archivo articulos XML> tipo [tamaño bloque]] \n", s);
 116         printf("  -f indica que lo que está a continuación seran los datos para generar el archivo de facturas.\n");
 117         printf("  -a indica que lo que está a continuación seran los datos para generar el archivo de articulos.\n");
 118         printf("  'tipo' es el modo de archivo. Siendo :\n");
 119         printf("     1 - Registros long. variables con bloque parametrizado\n");
 120         printf("     2 - Registros long. variables sin bloque\n");
 121         printf("     3 - Registros long fija con bloque parametrizado\n");
 122         printf("  tamaño bloque debe ser especificado solo en aquellos tipos que lo requiera.\n");
 123 }
 124
 125 int main(int argc, char *argv[])
 126 {
 127         int c, fin=0;
 128         WINDOW *dialog;
 129
 130         parametros.xml_art = parametros.xml_fact = -1;
 131         switch (param_ok(argc, argv)) {
 132                 case SHOW_HELP:
 133                         print_help(argv[0]);
 134                         return 0;
 135                 case TIPO_NO_DEFINIDO:
 136                         printf("Falta parámetro requerido.\nLuego del nombre del archivo debe especificar el tipo de archivo\n");
 137                         return 1;
 138                 case BLOQUE_NO_DEFINIDO:
 139                         printf("Falta parámetro requerido.\nLuego del tipo de archivo debe especificar el tamaño del bloque a utilizar\n");
 140                         return 1;
 141                 case TIPO_INVALIDO:
 142                         printf("Tipo de archivo no valido. Los valores posibles para el tipo de archivo son:\n");
 143                         printf("\t1 - Archivo de bloque parametrizado y registro de long. variable.\n");
 144                         printf("\t2 - Archivo de registros variables sin bloques.\n");
 145                         printf("\t3 - Archivos de bloque parametrizado y registro de long. parametrizada.\n");
 146                         return 2;
 147                 case NO_ART_FILE:
 148                         printf("Falta parámetro requerido.\nHa utilizado el modificador -a para crear los articulos a partir de un XML pero no ha especificado ningún archivo XML.\n");
 149                         return 3;
 150                 case NO_FACT_FILE:
 151                         printf("Falta parámetro requerido.\nHa utilizado el modificador -f para crear las facturas a partir de un XML pero no ha especificado ningún archivo XML.\n");
 152                         return 3;
 153                 case NULL_BLOCK_FOUND:
 154                         printf("Error de parámerto.\nHa ingresado un valor nulo como tamaño de bloque.\n");
 155                         return 4;
 156                 case PARAM_OK:
 157                         fin = 0;
 158         }
 159
 160 #ifdef DEBUG
 161         printf("CUIDADO! - Uds esta a punto de ejecutar EMUFS Gui compilado con mensajes de debug (-DDEBUG). ");
 162         printf("Esto puede causar que ante un error alguna función trate de emitir un mensaje por pantalla ");
 163         printf("haciendo que el aspecto visual se vea desvirtuado.\n\n");
 164         printf("Todos los mensajes de error se envian por stderr, por lo que es conveniente que vuelva a ejecutar ");
 165         printf("el programa de la siguiente manera :\n");
 166         printf("\t#> %s <parametros> 2> error.log\n\n", argv[0]);
 167         printf("De esta forma el SO se encargaga de redirigir stderr al archivo error.log y evitar algun problema en ");
 168         printf("visualizacion de la aplicacion.\n");
 169         printf("Para continuar **bajo su propio riesgo** presione una tecla. Puede cancelar la ejecucion en este punto con CTRL+C\n");
 170         fgetc(stdin);
 171 #endif
 172
 173         /* Inicio Curses */
 174         signal(SIGINT, finish);
 175         initscr();
 176         keypad(stdscr, TRUE);
 177         nonl();
 178         cbreak();
 179         noecho();
 180         /* Si se soporta color, los inicializo */
 181         if (has_colors()) {
 182                 start_color();
 183                 /* Simple color assignment, often all we need. */
 184                 init_pair(COLOR_BLACK, COLOR_BLACK, COLOR_BLACK); /* COLOR_PAIR(1) */
 185                 init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK);
 186                 init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK);
 187                 init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK);
 188                 init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK);
 189                 init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK);
 190                 init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK);
 191                 init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK);
 192         }
 193
 194         /* Verifico un tamaño minimo de consola */
 195         if ((LINES < 25) || (COLS < 80)) {
 196                 endwin();
 197                 printf("El tamaño de la consola debe ser de por lo menos 80x25!\n");
 198                 return 1;
 199         }
 200
 201         /* Ventana, caracter para linea vertical, caracter para linea horizontal*/
 202         box(stdscr, ACS_VLINE, ACS_HLINE);
 203         /* Ventana, Y, X, Texto */
 204         mvwaddstr(stdscr, 1, 1, "EMUFS");
 205         attron(COLOR_PAIR(2));
 206         mvwaddstr(stdscr, LINES-2, 1, "EMUFS (c) The EMUFS Team - Bajo Licencia GNU/GPL");
 207         attroff(COLOR_PAIR(2));
 208         wrefresh(stdscr);
 209
 210         dialog = msg_box(stdscr, COLS, LINES, "Generando archivos ...");
 211
 212         if (parametros.xml_art != -1) {
 213                 art_cargar(argv[parametros.xml_art], parametros.tipo_arch_art, parametros.tam_bloque_art);
 214         } else {
 215                 art_cargar(NULL, -1, -1);
 216         }
 217         if (parametros.xml_fact != -1) {
 218                 fact_cargar(argv[parametros.xml_fact], parametros.tipo_arch_fact, parametros.tam_bloque_fact);
 219         } else {
 220                 fact_cargar(NULL, -1, -1);
 221         }
 222
 223         msg_box_free(stdscr, dialog);
 224
 225         /* CICLO PRINCIPAL DE LA APLICACION */
 226         while ((c = main_menu()) != -1) {
 227                 switch (c) {
 228                         case 0:
 229                                 menu_articulos();
 230                         break;
 231                         case 1:
 232                                 menu_facturas();
 233                         break;
 234                         case 2:
 235                                 dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1);
 236                                 ver_registros(dialog, COLS-2, LINES-4);
 237                                 werase(dialog);
 238                                 wrefresh(dialog);
 239                                 delwin(dialog);
 240                                 refresh();
 241                         break;
 242                         case 5:
 243                                 menu_estadisticas();
 244                         break;
 245                         case 6:
 246                                 menu_mantenimiento();
 247                         break;
 248                         case 7:
 249                                 fin = 1;
 250                         break;
 251                 }
 252                 if (fin == 1) break;
 253         }
 254
 255         endwin();
 256
 257         art_liberar(NULL);
 258         fact_liberar(NULL);
 259
 260         return 0;
 261 }
 262
 263 void menu_facturas()
 264 {
 265         MENU(mi_menu) {
 266                 MENU_OPCION("Alta", "Crear una nueva factura."),
 267                 MENU_OPCION("Baja", "Elimina una factura existente."),
 268                 MENU_OPCION("Modificacion", "Modifica una factura existente."),
 269                 MENU_OPCION("Volver", "Volver al menu anterior.")
 270         };
 271         int opt;
 272
 273         while ((opt = menu_ejecutar(mi_menu, 4, "Menu Articulos")) != 3) {
 274                 switch (opt) {
 275                         case 0:
 276                                 fact_agregar(NULL);
 277                         break;
 278                         case 1:
 279                                 fact_eliminar(NULL);
 280                         break;
 281                         case 2:
 282                                 fact_modificar(NULL);
 283                 }
 284         }
 285 }
 286
 287 void menu_articulos()
 288 {
 289         MENU(mi_menu) {
 290                 MENU_OPCION("Alta", "Crear un nuevo articulo."),
 291                 MENU_OPCION("Baja", "Elimina un articulo existente."),
 292                 MENU_OPCION("Modificacion", "Modifica un articulo existente."),
 293                 MENU_OPCION("Volver", "Volver al menu anterior.")
 294         };
 295         int opt;
 296
 297         while ((opt = menu_ejecutar(mi_menu, 4, "Menu Articulos")) != 3) {
 298                 switch (opt) {
 299                         case 0:
 300                                 art_agregar(NULL);
 301                         break;
 302                         case 1:
 303                                 art_eliminar(NULL);
 304                         break;
 305                         case 2:
 306                                 art_modificar(NULL);
 307                 }
 308         }
 309
 310 }
 311
 312 void menu_estadisticas()
 313 {
 314         MENU(mi_menu) {
 315                 MENU_OPCION("Articulos", "Ver datos del archivo de Articulos."),
 316                 MENU_OPCION("Facturas", "Ver datos del archivo de Facturas."),
 317                 MENU_OPCION("Notas", "Ver datos del archivo de Notas."),
 318                 MENU_OPCION("Volver", "Ir al menu anterior.")
 319         };
 320         int opt;
 321
 322         while ((opt = menu_ejecutar(mi_menu, 4, "Menu Estadisticas")) != 3) {
 323                 switch (opt) {
 324                         case 0:
 325                                 ver_estadisticas( art_get_lst()->fp );
 326                         break;
 327                         case 1:
 328                                 ver_estadisticas( fact_get_lst()->fp );
 329                         break;
 330                         case 2:
 331                                 ver_estadisticas( fact_get_lst()->fp_texto );
 332                 }
 333         }
 334 }
 335
 336 int main_menu()
 337 {
 338         MENU(mi_menu) {
 339                 MENU_OPCION("Articulos","Alta,baja,consulta y modificacion de articulos."),
 340                 MENU_OPCION("Facturas","Alta,baja,consulta y modificacion de facturas."),
 341                 MENU_OPCION("Ver Registros","Ver registros/bloques de archivo Articulos."),
 342                 MENU_OPCION("Ver Facturas","Ver registros/bloques de archivo Facturas."),
 343                 MENU_OPCION("Ver Notas","Ver registros/bloques de archivo Notas."),
 344                 MENU_OPCION("Estadisticas","Ver estadisticas de ocupacion de archivos."),
 345                 MENU_OPCION("Mantenimiento","Tareas de mantenimiento de los archivos."),
 346                 MENU_OPCION("Salir", "Salir del sistema.")
 347         };
 348
 349         return menu_ejecutar(mi_menu, 8, "Menu Principal");
 350 }
 351
 352
 353 static void finish(int sig)
 354 {
 355         endwin();
 356
 357         /* do your non-curses wrapup here */
 358         exit(0);
 359 }
 360
 361 WINDOW *msg_box(WINDOW *win, int w, int h, const char *format, ...)
 362 {
 363         va_list ap;
 364         char txt[255];
 365         int mw, mh;
 366         WINDOW *dialog;
 367         va_start(ap, format);
 368         vsprintf(txt, format, ap);
 369         va_end(ap);
 370
 371         mw = strlen(txt)+2;
 372         mh = 3;
 373         dialog = derwin(win, mh, mw, h/2-mh/2, w/2-mw/2);
 374         box(dialog, 0 ,0);
 375         mvwaddstr(dialog, 1, 1, txt);
 376         wrefresh(dialog);
 377         curs_set(0);
 378         return dialog;
 379 }
 380
 381 void msg_box_free(WINDOW *padre, WINDOW *win)
 382 {
 383         werase(win);
 384         wrefresh(win);
 385         delwin(win);
 386         curs_set(1);
 387         wrefresh(padre);
 388 }
 389
 390 void menu_mantenimiento()
 391 {
 392         MENU(mi_menu) {
 393                 MENU_OPCION("Compactar Articulos","Elimina espacio no utilizado."),
 394                 MENU_OPCION("Compactar Facturas","Elimina espacio no utilizado."),
 395                 MENU_OPCION("Compactar Notas","Elimina espacio no utilizado."),
 396                 MENU_OPCION("Cambiar tipo Archivo Articulos","Permite cambiar el tipo del archivo."),
 397                 MENU_OPCION("Cambiar tipo Archivo Facturas","Permite cambiar el tipo del archivo."),
 398                 MENU_OPCION("Cambiar tipo Archivo Notas","Permite cambiar el tipo del archivo."),
 399                 MENU_OPCION("Volver", "Volver al menu anterior.")
 400         };
 401
 402         int opt;
 403         int nuevo_tam_registro, nuevo_tam_bloque;
 404         int nuevo_tipo;
 405         WINDOW *dlg;
 406
 407         while ((opt = menu_ejecutar(mi_menu, 7, "Menu Mantenimiento")) != 6) {
 408                 switch (opt) {
 409                         case 0:
 410                                 dlg = msg_box(stdscr, COLS, LINES, "Compactando archivo.... Aguarde");
 411                                 art_get_lst()->fp->compactar(art_get_lst()->fp);
 412                                 msg_box_free(stdscr, dlg);
 413                         break;
 414                         case 1:
 415                                 dlg = msg_box(stdscr, COLS, LINES, "Compactando archivo.... Aguarde");
 416                                 fact_get_lst()->fp->compactar(fact_get_lst()->fp);
 417                                 msg_box_free(stdscr, dlg);
 418                         break;
 419                         case 2:
 420                                 dlg = msg_box(stdscr, COLS, LINES, "Compactando archivo.... Aguarde");
 421                                 fact_get_lst()->fp_texto->compactar(fact_get_lst()->fp_texto);
 422                                 msg_box_free(stdscr, dlg);
 423                         break;
 424                         case 3:
 425                                 nuevo_tam_registro = -1; /* No permito cambiar el tamaño de registro */
 426                                 preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro);
 427                                 dlg = msg_box(stdscr, COLS, LINES, "Cambiando el formato de archivo .... Aguarde");
 428                                 art_reformatear(nuevo_tipo, nuevo_tam_bloque, nuevo_tam_registro);
 429                                 msg_box_free(stdscr, dlg);
 430                         break;
 431                         case 4:
 432                                 nuevo_tam_registro = 0;
 433                                 preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro);
 434                         break;
 435                         case 5:
 436                                 nuevo_tam_registro = -2;
 437                                 preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro);
 438                 }
 439         }
 440 }
 441
 442 void preguntar_nuevo_tipo(int *tipo, int *tam_bloque, int *tam_reg)
 443 {
 444         WINDOW *win;
 445         t_Form *form;
 446         char *s;
 447         int n, is_ok;
 448
 449         win = newwin(LINES/2, COLS/2, LINES/4, COLS/4);
 450         box(win, 0, 0);
 451
 452         form = form_crear(win);
 453         form_agregar_widget(form, RADIO, "Tipo de archivo", 3, "T1,T2,T3");
 454         form_ejecutar(form, 1,1);
 455
 456         s = form_obtener_valor_char(form, "Tipo de archivo");
 457         if (strcmp(s, "T1") == 0) n = T1;
 458         if (strcmp(s, "T2") == 0) n = T2;
 459         if (strcmp(s, "T3") == 0) n = T3;
 460
 461         form_destruir(form);
 462
 463         werase(win);
 464         box(win, 0, 0);
 465         wrefresh(win);
 466
 467         (*tipo) = n;
 468         switch (n) {
 469                 case T1:
 470                         form = form_crear(win);
 471                         form_agregar_widget(form, INPUT, "Tamaño de bloque", 8, "");
 472                         is_ok = 0;
 473                         do {
 474                                 form_set_valor(form, "Tamaño de bloque", "");
 475                                 form_ejecutar(form, 1,1);
 476                                 if (form_obtener_valor_int(form, "Tamaño de bloque") > 0) is_ok = 1;
 477                         } while (!is_ok);
 478                         (*tam_bloque) = form_obtener_valor_int(form, "Tamaño de bloque");
 479                         form_destruir(form);
 480                 break;
 481                 case T2:
 482                         break;
 483                 case T3:
 484                         if (((*tam_reg) != -1) && ((*tam_reg) != -2)) {
 485                                 mvwaddstr(win, LINES/2-3, 1, "Nota: El tamaño de registro puede");
 486                                 mvwaddstr(win, LINES/2-2, 1, "llegar a ser redondeado por el sistema.");
 487                         }
 488                         form = form_crear(win);
 489                         form_agregar_widget(form, INPUT, "Tamaño de bloque", 8, "");
 490                         if ((*tam_reg) != -1)
 491                                 form_agregar_widget(form, INPUT, "Tamaño de registro", 8, "");
 492                         is_ok = 0;
 493                         do {
 494                                 form_set_valor(form, "Tamaño de bloque", "");
 495                                 if ((*tam_reg) != -1)
 496                                         form_set_valor(form, "Tamaño de registro", "");
 497                                 form_ejecutar(form, 1,1);
 498                                 if (form_obtener_valor_int(form, "Tamaño de bloque") > 0) is_ok = 1;
 499                                 if ((*tam_reg) != -1) {
 500                                         if (form_obtener_valor_int(form, "Tamaño de registro") > 0) is_ok = 1; else is_ok = 0;
 501                                 }
 502                         } while (!is_ok);
 503                         (*tam_bloque) = form_obtener_valor_int(form, "Tamaño de bloque");
 504                         if ((*tam_reg) != -1)
 505                                 (*tam_reg) = form_obtener_valor_int(form, "Tamaño de registro");
 506                         form_destruir(form);
 507         }
 508         werase(win);
 509         wrefresh(win);
 510         delwin(win);
 511 }
 512
 513 void ver_estadisticas(EMUFS *fp)
 514 {
 515         WINDOW *win;
 516         EMUFS_Estadisticas stats;
 517         char s[40];
 518         int i=3;
 519
 520         stats = fp->leer_estadisticas(fp);
 521
 522         win = newwin(LINES-4, COLS-2, 2, 1);
 523         curs_set(0);
 524
 525         wattron(win, COLOR_PAIR(COLOR_YELLOW));
 526         wattron(win, A_BOLD);
 527         mvwaddstr(win, 1, 1, "Tipo de Archivo : ");
 528         wattroff(win, A_BOLD);
 529         wattroff(win, COLOR_PAIR(COLOR_YELLOW));
 530         switch (fp->tipo) {
 531                 case T1:
 532                         waddstr(win, "Registro long. variable con bloque parametrizado");
 533                         wattron(win, A_BOLD);
 534                         mvwaddstr(win, i++, 1, "Tamaño de bloque : ");
 535                         wattroff(win, A_BOLD);
 536                         sprintf(s, "%lu bytes", fp->tam_bloque);
 537                         waddstr(win, s);
 538                 break;
 539                 case T2:
 540                         waddstr(win, "Registro long. variable sin bloques");
 541                 break;
 542                 case T3:
 543                         waddstr(win, "Registro long. fija con bloque parametrizado");
 544                         wattron(win, A_BOLD);
 545                         mvwaddstr(win, i++, 1, "Tamaño de bloque : ");
 546                         wattroff(win, A_BOLD);
 547                         sprintf(s, "%lu bytes", fp->tam_bloque);
 548                         waddstr(win, s);
 549                         wattron(win, A_BOLD);
 550                         mvwaddstr(win, i++, 1, "Tamaño de registro : ");
 551                         wattroff(win, A_BOLD);
 552                         sprintf(s, "%lu bytes", fp->tam_reg);
 553                         waddstr(win, s);
 554         }
 555
 556         wattron(win, A_BOLD);
 557         mvwaddstr(win, i++, 1, "Cant. Registros : ");
 558         wattroff(win, A_BOLD);
 559         sprintf(s, "%lu", stats.tam_archivo);
 560         waddstr(win, s);
 561
 562         wattron(win, A_BOLD);
 563         mvwaddstr(win, i++, 1, "Tamaño de Archivo : ");
 564         wattroff(win, A_BOLD);
 565         sprintf(s, "%lu bytes", stats.tam_archivo_bytes);
 566         waddstr(win, s);
 567
 568         wattron(win, A_BOLD);
 569         mvwaddstr(win, i++, 1, "Tamaño de Info de Control : ");
 570         wattroff(win, A_BOLD);
 571         sprintf(s, "%lu bytes", stats.info_control);
 572         waddstr(win, s);
 573
 574         wattron(win, A_BOLD);
 575         mvwaddstr(win, i++, 1, "Media de espacio libre : ");
 576         wattroff(win, A_BOLD);
 577         sprintf(s, "%lu bytes/bloque", stats.media_fs);
 578         waddstr(win, s);
 579
 580         wattron(win, A_BOLD);
 581         mvwaddstr(win, i++, 1, "Espacio Libre : ");
 582         wattroff(win, A_BOLD);
 583         sprintf(s, "%lu bytes", stats.total_fs);
 584         waddstr(win, s);
 585
 586         wattron(win, A_BOLD);
 587         mvwaddstr(win, i++, 1, "Maximo de Espacio libre : ");
 588         wattroff(win, A_BOLD);
 589         sprintf(s, "%lu bytes", stats.max_fs);
 590         waddstr(win, s);
 591
 592         wattron(win, A_BOLD);
 593         mvwaddstr(win, i++, 1, "Minimo de Espacio libre : ");
 594         wattroff(win, A_BOLD);
 595         sprintf(s, "%lu bytes", stats.min_fs);
 596         waddstr(win, s);
 597
 598         wattron(win, A_BOLD);
 599         mvwaddstr(win, i++, 1, "Cantidad de bloques : ");
 600         wattroff(win, A_BOLD);
 601         sprintf(s, "%lu", stats.cant_bloques);
 602         waddstr(win, s);
 603
 604         wattron(win, A_BLINK);
 605         mvwaddstr(win, i+2, 1, "Presione una tecla para continuar.");
 606         wattroff(win, A_BLINK);
 607
 608         wrefresh(win);
 609
 610         getch();
 611         werase(win);
 612         wrefresh(win);
 613         delwin(win);
 614 }
 615