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